[compiler-rt] Use empty SuspendedThreadsList for Fuchsia

[phosek]

Summary

d48f2d7 made destructor of SuspendedThreadsList protected, so we need
an empty subclass to pass to the callback now.

[vitalybuka]

Sorry for that.
Does fuchsia has any build bots? Would be nice to get automatic email about such breaks.

[vitalybuka]

5 seconds? Is this a script? :)

[leonardchan]

In D90695#2371840, @vitalybuka wrote:

Sorry for that.
Does fuchsia has any build bots? Would be nice to get automatic email about such breaks.

We had one but it seems to have gone silent during the buildbot update. Definitely need to restart it for occasions like these.

compiler-rt/lib/lsan/lsan_common_fuchsia.cpp

 #include "lsan_common.h"
 #include "sanitizer_common/sanitizer_platform.h"
 
 #if CAN_SANITIZE_LEAKS && SANITIZER_FUCHSIA
 #include <zircon/sanitizer.h>
 
 #include "lsan_allocator.h"
 #include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_stoptheworld_fuchsia.h"
 #include "sanitizer_common/sanitizer_thread_registry.h"
 
 // Ensure that the Zircon system ABI is linked in.
 #pragma comment(lib, "zircon")
 
 namespace __lsan {
 
 void InitializePlatformSpecificModules() {}
__sanitizer_memory_snapshot(
           GetThreadRegistryLocked()->RunCallbackForEachThreadLocked(
               [](ThreadContextBase *tctx, void *arg) {
                 ForEachExtraStackRange(tctx->os_id, ForEachExtraStackRangeCb,
                                        arg);
               },
               &params->argument->frontier);
         }
 
-        params->callback({}, params->argument);
+        params->callback(SuspendedThreadsListFuchsia(), params->argument);
       },
       &params);
 
   UnlockAllocator();
   UnlockThreadRegistry();
 }
 
 }  // namespace __lsan
 
 // This is declared (in extern "C") by <zircon/sanitizer.h>.
 // _Exit calls this directly to intercept and change the status value.
 int __sanitizer_process_exit_hook(int status) {
   return __lsan::ExitHook(status);
 }
 
 #endif

compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld_fuchsia.h

+//===-- sanitizer_stoptheworld_fuchsia.h ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_STOPTHEWORLD_FUCHSIA_H
+#define SANITIZER_STOPTHEWORLD_FUCHSIA_H
+
+#include "sanitizer_stoptheworld.h"
+
+namespace __sanitizer {
+
+class SuspendedThreadsListFuchsia final : public SuspendedThreadsList {};
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_STOPTHEWORLD_FUCHSIA_H

compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld_fuchsia.cpp

 
 #include "sanitizer_platform.h"
 
 #if SANITIZER_FUCHSIA
 
 #include <zircon/sanitizer.h>
 
 #include "sanitizer_stoptheworld.h"
+#include "sanitizer_stoptheworld_fuchsia.h"
 
 namespace __sanitizer {
 
 // The Fuchsia implementation stops the world but doesn't offer a real
 // SuspendedThreadsList argument.  This is enough for ASan's use case,
 // and LSan does not use this API on Fuchsia.
 void StopTheWorld(StopTheWorldCallback callback, void *argument) {
   struct Params {
     StopTheWorldCallback callback;
     void *argument;
   } params = {callback, argument};
   __sanitizer_memory_snapshot(
       nullptr, nullptr, nullptr, nullptr,
       [](zx_status_t, void *data) {
         auto params = reinterpret_cast<Params *>(data);
-        params->callback({}, params->argument);
+        params->callback(SuspendedThreadsListFuchsia(), params->argument);
       },
       &params);
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FUCHSIA