Index: lib/tsan/rtl/tsan_debugging.cc
===================================================================
--- lib/tsan/rtl/tsan_debugging.cc
+++ lib/tsan/rtl/tsan_debugging.cc
@@ -20,31 +20,37 @@
 using namespace __tsan;
 
 static const char *ReportTypeDescription(ReportType typ) {
-  if (typ == ReportTypeRace) return "data-race";
-  if (typ == ReportTypeVptrRace) return "data-race-vptr";
-  if (typ == ReportTypeUseAfterFree) return "heap-use-after-free";
-  if (typ == ReportTypeVptrUseAfterFree) return "heap-use-after-free-vptr";
-  if (typ == ReportTypeExternalRace) return "external-race";
-  if (typ == ReportTypeThreadLeak) return "thread-leak";
-  if (typ == ReportTypeMutexDestroyLocked) return "locked-mutex-destroy";
-  if (typ == ReportTypeMutexDoubleLock) return "mutex-double-lock";
-  if (typ == ReportTypeMutexInvalidAccess) return "mutex-invalid-access";
-  if (typ == ReportTypeMutexBadUnlock) return "mutex-bad-unlock";
-  if (typ == ReportTypeMutexBadReadLock) return "mutex-bad-read-lock";
-  if (typ == ReportTypeMutexBadReadUnlock) return "mutex-bad-read-unlock";
-  if (typ == ReportTypeSignalUnsafe) return "signal-unsafe-call";
-  if (typ == ReportTypeErrnoInSignal) return "errno-in-signal-handler";
-  if (typ == ReportTypeDeadlock) return "lock-order-inversion";
-  return "";
+  switch (typ) {
+    case ReportTypeRace: return "data-race";
+    case ReportTypeVptrRace: return "data-race-vptr";
+    case ReportTypeUseAfterFree: return "heap-use-after-free";
+    case ReportTypeVptrUseAfterFree: return "heap-use-after-free-vptr";
+    case ReportTypeExternalRace: return "external-race";
+    case ReportTypeThreadLeak: return "thread-leak";
+    case ReportTypeMutexDestroyLocked: return "locked-mutex-destroy";
+    case ReportTypeMutexDoubleLock: return "mutex-double-lock";
+    case ReportTypeMutexInvalidAccess: return "mutex-invalid-access";
+    case ReportTypeMutexBadUnlock: return "mutex-bad-unlock";
+    case ReportTypeMutexBadReadLock: return "mutex-bad-read-lock";
+    case ReportTypeMutexBadReadUnlock: return "mutex-bad-read-unlock";
+    case ReportTypeSignalUnsafe: return "signal-unsafe-call";
+    case ReportTypeErrnoInSignal: return "errno-in-signal-handler";
+    case ReportTypeDeadlock: return "lock-order-inversion";
+    // No default case so compiler warns us if we miss one
+  }
+  UNREACHABLE("missing case");
 }
 
 static const char *ReportLocationTypeDescription(ReportLocationType typ) {
-  if (typ == ReportLocationGlobal) return "global";
-  if (typ == ReportLocationHeap) return "heap";
-  if (typ == ReportLocationStack) return "stack";
-  if (typ == ReportLocationTLS) return "tls";
-  if (typ == ReportLocationFD) return "fd";
-  return "";
+  switch (typ) {
+    case ReportLocationGlobal: return "global";
+    case ReportLocationHeap: return "heap";
+    case ReportLocationStack: return "stack";
+    case ReportLocationTLS: return "tls";
+    case ReportLocationFD: return "fd";
+    // No default case so compiler warns us if we miss one
+  }
+  UNREACHABLE("missing case");
 }
 
 static void CopyTrace(SymbolizedStack *first_frame, void **trace,
Index: lib/tsan/rtl/tsan_report.cc
===================================================================
--- lib/tsan/rtl/tsan_report.cc
+++ lib/tsan/rtl/tsan_report.cc
@@ -77,39 +77,42 @@
 }
 
 static const char *ReportTypeString(ReportType typ, uptr tag) {
-  if (typ == ReportTypeRace)
-    return "data race";
-  if (typ == ReportTypeVptrRace)
-    return "data race on vptr (ctor/dtor vs virtual call)";
-  if (typ == ReportTypeUseAfterFree)
-    return "heap-use-after-free";
-  if (typ == ReportTypeVptrUseAfterFree)
-    return "heap-use-after-free (virtual call vs free)";
-  if (typ == ReportTypeExternalRace) {
-    const char *str = GetReportHeaderFromTag(tag);
-    return str ? str : "race on external object";
+  switch (typ) {
+    case ReportTypeRace:
+      return "data race";
+    case ReportTypeVptrRace:
+      return "data race on vptr (ctor/dtor vs virtual call)";
+    case ReportTypeUseAfterFree:
+      return "heap-use-after-free";
+    case ReportTypeVptrUseAfterFree:
+      return "heap-use-after-free (virtual call vs free)";
+    case ReportTypeExternalRace: {
+      const char *str = GetReportHeaderFromTag(tag);
+      return str ? str : "race on external object";
+    }
+    case ReportTypeThreadLeak:
+      return "thread leak";
+    case ReportTypeMutexDestroyLocked:
+      return "destroy of a locked mutex";
+    case ReportTypeMutexDoubleLock:
+      return "double lock of a mutex";
+    case ReportTypeMutexInvalidAccess:
+      return "use of an invalid mutex (e.g. uninitialized or destroyed)";
+    case ReportTypeMutexBadUnlock:
+      return "unlock of an unlocked mutex (or by a wrong thread)";
+    case ReportTypeMutexBadReadLock:
+      return "read lock of a write locked mutex";
+    case ReportTypeMutexBadReadUnlock:
+      return "read unlock of a write locked mutex";
+    case ReportTypeSignalUnsafe:
+      return "signal-unsafe call inside of a signal";
+    case ReportTypeErrnoInSignal:
+      return "signal handler spoils errno";
+    case ReportTypeDeadlock:
+      return "lock-order-inversion (potential deadlock)";
+    // No default case so compiler warns us if we miss one
   }
-  if (typ == ReportTypeThreadLeak)
-    return "thread leak";
-  if (typ == ReportTypeMutexDestroyLocked)
-    return "destroy of a locked mutex";
-  if (typ == ReportTypeMutexDoubleLock)
-    return "double lock of a mutex";
-  if (typ == ReportTypeMutexInvalidAccess)
-    return "use of an invalid mutex (e.g. uninitialized or destroyed)";
-  if (typ == ReportTypeMutexBadUnlock)
-    return "unlock of an unlocked mutex (or by a wrong thread)";
-  if (typ == ReportTypeMutexBadReadLock)
-    return "read lock of a write locked mutex";
-  if (typ == ReportTypeMutexBadReadUnlock)
-    return "read unlock of a write locked mutex";
-  if (typ == ReportTypeSignalUnsafe)
-    return "signal-unsafe call inside of a signal";
-  if (typ == ReportTypeErrnoInSignal)
-    return "signal handler spoils errno";
-  if (typ == ReportTypeDeadlock)
-    return "lock-order-inversion (potential deadlock)";
-  return "";
+  UNREACHABLE("missing case");
 }
 
 #if SANITIZER_MAC
Index: lib/tsan/rtl/tsan_suppressions.cc
===================================================================
--- lib/tsan/rtl/tsan_suppressions.cc
+++ lib/tsan/rtl/tsan_suppressions.cc
@@ -66,38 +66,31 @@
 }
 
 static const char *conv(ReportType typ) {
-  if (typ == ReportTypeRace)
-    return kSuppressionRace;
-  else if (typ == ReportTypeVptrRace)
-    return kSuppressionRace;
-  else if (typ == ReportTypeUseAfterFree)
-    return kSuppressionRace;
-  else if (typ == ReportTypeVptrUseAfterFree)
-    return kSuppressionRace;
-  else if (typ == ReportTypeExternalRace)
-    return kSuppressionRace;
-  else if (typ == ReportTypeThreadLeak)
-    return kSuppressionThread;
-  else if (typ == ReportTypeMutexDestroyLocked)
-    return kSuppressionMutex;
-  else if (typ == ReportTypeMutexDoubleLock)
-    return kSuppressionMutex;
-  else if (typ == ReportTypeMutexInvalidAccess)
-    return kSuppressionMutex;
-  else if (typ == ReportTypeMutexBadUnlock)
-    return kSuppressionMutex;
-  else if (typ == ReportTypeMutexBadReadLock)
-    return kSuppressionMutex;
-  else if (typ == ReportTypeMutexBadReadUnlock)
-    return kSuppressionMutex;
-  else if (typ == ReportTypeSignalUnsafe)
-    return kSuppressionSignal;
-  else if (typ == ReportTypeErrnoInSignal)
-    return kSuppressionNone;
-  else if (typ == ReportTypeDeadlock)
-    return kSuppressionDeadlock;
-  Printf("ThreadSanitizer: unknown report type %d\n", typ);
-  Die();
+  switch (typ) {
+    case ReportTypeRace:
+    case ReportTypeVptrRace:
+    case ReportTypeUseAfterFree:
+    case ReportTypeVptrUseAfterFree:
+    case ReportTypeExternalRace:
+      return kSuppressionRace;
+    case ReportTypeThreadLeak:
+      return kSuppressionThread;
+    case ReportTypeMutexDestroyLocked:
+    case ReportTypeMutexDoubleLock:
+    case ReportTypeMutexInvalidAccess:
+    case ReportTypeMutexBadUnlock:
+    case ReportTypeMutexBadReadLock:
+    case ReportTypeMutexBadReadUnlock:
+      return kSuppressionMutex;
+    case ReportTypeSignalUnsafe:
+      return kSuppressionSignal;
+    case ReportTypeErrnoInSignal:
+      return kSuppressionNone;
+    case ReportTypeDeadlock:
+      return kSuppressionDeadlock;
+    // No default case so compiler warns us if we miss one
+  }
+  UNREACHABLE("missing case");
 }
 
 static uptr IsSuppressed(const char *stype, const AddressInfo &info,