[llvm] Remove os/signpost.h include from Signposts.h

[JDevlieghere]

Summary

Remove the os/signpost.h header include from Signposts.h. In some SDKs the header transitively includes defines that conflict with the enums in MachO.h.

lldb/include/lldb/Utility/Timer.h

 #define LLDB_UTILITY_TIMER_H
 
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/Signposts.h"
 #include <atomic>
 #include <cstdint>
 
+#if LLVM_SUPPORT_XCODE_SIGNPOSTS
+#include <os/signpost.h>
+/// A macro to take advantage of the special format string handling
+/// in the os_signpost API. The format string substitution is
+/// deferred to the log consumer and done outside of the
+/// application.
+#define SIGNPOST_EMITTER_START_INTERVAL(SIGNPOST_EMITTER, O, ...)              \
+  do {                                                                         \
+    if ((SIGNPOST_EMITTER).isEnabled())                                        \
+      if (SIGNPOSTS_AVAILABLE())                                               \
+        os_signpost_interval_begin(                                            \
+            *(os_log_t *)(SIGNPOST_EMITTER).getLogger(),                       \
+            *(os_signpost_id_t *)(SIGNPOST_EMITTER).getSignpostForObject(O),   \
+            "LLVM Timers", __VA_ARGS__);                                       \
+  } while (0)
+#else
+#define SIGNPOST_EMITTER_START_INTERVAL(SIGNPOST_EMITTER, O, ...)              \
+  do {                                                                         \
+  } while (0)
+#endif
+
 namespace llvm {
   class SignpostEmitter;
 }
 
 namespace lldb_private {
 class Stream;
 
 /// \class Timer Timer.h "lldb/Utility/Timer.h"

llvm/include/llvm/Support/Signposts.h

 #define LLVM_SUPPORT_SIGNPOSTS_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/llvm-config.h"
 #include <memory>
 
 #if LLVM_SUPPORT_XCODE_SIGNPOSTS
 #include <Availability.h>
-#include <os/signpost.h>
 #endif
 
 #define SIGNPOSTS_AVAILABLE()                                                  \
   __builtin_available(macos 10.14, iOS 12, tvOS 12, watchOS 5, *)
 
 namespace llvm {
 class SignpostEmitterImpl;
 
 /// Manages the emission of signposts into the recording method supported by
 /// the OS.
 class SignpostEmitter {
   std::unique_ptr<SignpostEmitterImpl> Impl;
 
 public:
   SignpostEmitter();
   ~SignpostEmitter();
 
   bool isEnabled() const;
 
   /// Begin a signposted interval for a given object.
   void startInterval(const void *O, StringRef Name);
 
 #if LLVM_SUPPORT_XCODE_SIGNPOSTS
-  os_log_t &getLogger() const;
-  os_signpost_id_t getSignpostForObject(const void *O);
-#endif
-
-  /// A macro to take advantage of the special format string handling
-  /// in the os_signpost API. The format string substitution is
-  /// deferred to the log consumer and done outside of the
-  /// application.
-#if LLVM_SUPPORT_XCODE_SIGNPOSTS
-#define SIGNPOST_EMITTER_START_INTERVAL(SIGNPOST_EMITTER, O, ...)              \
-  do {                                                                         \
-    if ((SIGNPOST_EMITTER).isEnabled())                                        \
-      if (SIGNPOSTS_AVAILABLE())                                               \
-        os_signpost_interval_begin((SIGNPOST_EMITTER).getLogger(),             \
-                                   (SIGNPOST_EMITTER).getSignpostForObject(O), \
-                                   "LLVM Timers", __VA_ARGS__);                \
-  } while (0)
-#else
-#define SIGNPOST_EMITTER_START_INTERVAL(SIGNPOST_EMITTER, O, ...)              \
-  do {                                                                         \
-  } while (0)
+  void *getLogger() const;
+  void *getSignpostForObject(const void *O);
 #endif
 
   /// End a signposted interval for a given object.
   void endInterval(const void *O);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_SIGNPOSTS_H

llvm/lib/Support/Signposts.cpp

 //===-- Signposts.cpp - Interval debug annotations ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Signposts.h"
 #include "llvm/Support/Timer.h"
 
 #if LLVM_SUPPORT_XCODE_SIGNPOSTS
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Mutex.h"
+#include <os/signpost.h>
 #endif
 
 using namespace llvm;
 
 #if LLVM_SUPPORT_XCODE_SIGNPOSTS
 namespace {
 os_log_t *LogCreator() {
   os_log_t *X = new os_log_t;

 class SignpostEmitterImpl {
   using LogPtrTy = std::unique_ptr<os_log_t, LogDeleter>;
 
   LogPtrTy SignpostLog;
   DenseMap<const void *, os_signpost_id_t> Signposts;
   sys::SmartMutex<true> Mutex;
 
 public:
-  os_log_t &getLogger() const { return *SignpostLog; }
-  os_signpost_id_t getSignpostForObject(const void *O) {
+  os_log_t *getLogger() const { return SignpostLog.get(); }
+  os_signpost_id_t* getSignpostForObject(const void *O) {
     sys::SmartScopedLock<true> Lock(Mutex);
     const auto &I = Signposts.find(O);
     if (I != Signposts.end())
-      return I->second;
+      return &I->second;
     os_signpost_id_t ID = {};
     if (SIGNPOSTS_AVAILABLE()) {
-      ID = os_signpost_id_make_with_pointer(getLogger(), O);
+      ID = os_signpost_id_make_with_pointer(*getLogger(), O);
     }
     const auto &Inserted = Signposts.insert(std::make_pair(O, ID));
-    return Inserted.first->second;
+    return &Inserted.first->second;
   }
 
   SignpostEmitterImpl() : SignpostLog(LogCreator()) {}
 
   bool isEnabled() const {
     if (SIGNPOSTS_AVAILABLE())
       return os_signpost_enabled(*SignpostLog);
     return false;
   }
 
   void startInterval(const void *O, llvm::StringRef Name) {
     if (isEnabled()) {
       if (SIGNPOSTS_AVAILABLE()) {
         // Both strings used here are required to be constant literal strings.
-        os_signpost_interval_begin(getLogger(), getSignpostForObject(O),
+        os_signpost_interval_begin(*getLogger(), *getSignpostForObject(O),
                                    "LLVM Timers", "%s", Name.data());
       }
     }
   }
 
   void endInterval(const void *O) {
     if (isEnabled()) {
       if (SIGNPOSTS_AVAILABLE()) {
         // Both strings used here are required to be constant literal strings.
-        os_signpost_interval_end(getLogger(), getSignpostForObject(O),
+        os_signpost_interval_end(*getLogger(), *getSignpostForObject(O),
                                  "LLVM Timers", "");
       }
     }
   }
 };
 } // end namespace llvm
 #else
 /// Definition necessary for use of std::unique_ptr in SignpostEmitter::Impl.

 #if HAVE_ANY_SIGNPOST_IMPL
   if (Impl == nullptr)
     return;
   return Impl->startInterval(O, Name);
 #endif // if !HAVE_ANY_SIGNPOST_IMPL
 }
 
 #if HAVE_ANY_SIGNPOST_IMPL
-os_log_t &SignpostEmitter::getLogger() const { return Impl->getLogger(); }
-os_signpost_id_t SignpostEmitter::getSignpostForObject(const void *O) {
+void *SignpostEmitter::getLogger() const { return Impl->getLogger(); }
+void *SignpostEmitter::getSignpostForObject(const void *O) {
   return Impl->getSignpostForObject(O);
 }
 #endif
 
 void SignpostEmitter::endInterval(const void *O) {
 #if HAVE_ANY_SIGNPOST_IMPL
   if (Impl == nullptr)
     return;
   Impl->endInterval(O);
 #endif // if !HAVE_ANY_SIGNPOST_IMPL
 }