[lldb][NFCI] Remove use of ifdef __cpluplus where unneeded

[bulbazord]

Summary

Just about every file in the lldb project is built with C++ enabled.
Unless I've missed something, these macro guards don't really accomplish
very much.

[JDevlieghere]

LGTM

lldb/include/lldb/Core/Mangled.h

 //===-- Mangled.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 LLDB_CORE_MANGLED_H
 #define LLDB_CORE_MANGLED_H
-#if defined(__cplusplus)
 
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 #include "lldb/Utility/ConstString.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <cstddef>
private:
   mutable ConstString m_demangled; ///< Mutable so we can get it on demand with
                                    ///a const version of this object
 };
 
 Stream &operator<<(Stream &s, const Mangled &obj);
 
 } // namespace lldb_private
 
-#endif // #if defined(__cplusplus)
 #endif // LLDB_CORE_MANGLED_H

lldb/include/lldb/Host/Editline.h

 // broken, which is why we're working around it here.
 // c) The incremental search uses escape to cancel input, so it's confused by
 // ANSI sequences starting with escape.
 // d) Emoji support is fairly terrible, presumably it doesn't understand
 // composed characters?
 
 #ifndef LLDB_HOST_EDITLINE_H
 #define LLDB_HOST_EDITLINE_H
-#if defined(__cplusplus)
 
 #include "lldb/Host/Config.h"
 
 #if LLDB_EDITLINE_USE_WCHAR
 #include <codecvt>
 #endif
 #include <locale>
 #include <sstream>
#endif
   std::string m_suggestion_ansi_prefix;
   std::string m_suggestion_ansi_suffix;
 
   std::size_t m_previous_autosuggestion_size = 0;
   std::recursive_mutex &m_output_mutex;
 };
 }
 
-#endif // #if defined(__cplusplus)
 #endif // LLDB_HOST_EDITLINE_H

lldb/include/lldb/Host/Terminal.h

 //===-- Terminal.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 LLDB_HOST_TERMINAL_H
 #define LLDB_HOST_TERMINAL_H
-#if defined(__cplusplus)
 
 #include "lldb/lldb-private.h"
 #include "llvm/Support/Error.h"
 
 namespace lldb_private {
 
 class TerminalState;
 
protected:
   Terminal m_tty;                         ///< A terminal
   int m_tflags = -1;                      ///< Cached tflags information.
   std::unique_ptr<Terminal::Data> m_data; ///< Platform-specific implementation.
   lldb::pid_t m_process_group = -1;       ///< Cached process group information.
 };
 
 } // namespace lldb_private
 
-#endif // #if defined(__cplusplus)
 #endif // LLDB_HOST_TERMINAL_H

lldb/include/lldb/Host/posix/PipePosix.h

 //===-- PipePosix.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 LLDB_HOST_POSIX_PIPEPOSIX_H
 #define LLDB_HOST_POSIX_PIPEPOSIX_H
-#if defined(__cplusplus)
 
 #include "lldb/Host/PipeBase.h"
 
 namespace lldb_private {
 
 /// \class PipePosix PipePosix.h "lldb/Host/posix/PipePosix.h"
 /// A posix-based implementation of Pipe, a class that abtracts
 ///        unix style pipes.
Status ReadWithTimeout(void *buf, size_t size,
                          size_t &bytes_read) override;
 
 private:
   int m_fds[2];
 };
 
 } // namespace lldb_private
 
-#endif // #if defined(__cplusplus)
 #endif // LLDB_HOST_POSIX_PIPEPOSIX_H

lldb/include/lldb/Utility/DataBuffer.h

 //===-- DataBuffer.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 LLDB_UTILITY_DATABUFFER_H
 #define LLDB_UTILITY_DATABUFFER_H
-#if defined(__cplusplus)
 
 #include <cstdint>
 #include <cstring>
 
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
public:
   /// }
 private:
   uint8_t *m_bytes;
   lldb::offset_t m_size;
 };
 
 } // namespace lldb_private
 
-#endif /// #if defined(__cplusplus)
 #endif // LLDB_UTILITY_DATABUFFER_H

lldb/include/lldb/Utility/DataEncoder.h

 //===-- DataEncoder.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 LLDB_UTILITY_DATAENCODER_H
 #define LLDB_UTILITY_DATAENCODER_H
 
-#if defined(__cplusplus)
-
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
private:
   const uint8_t m_addr_size;
 
   DataEncoder(const DataEncoder &) = delete;
   const DataEncoder &operator=(const DataEncoder &) = delete;
 };
 
 } // namespace lldb_private
 
-#endif // #if defined (__cplusplus)
 #endif // LLDB_UTILITY_DATAENCODER_H

lldb/include/lldb/lldb-forward.h

 //===-- lldb-forward.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 LLDB_LLDB_FORWARD_H
 #define LLDB_LLDB_FORWARD_H
 
-#if defined(__cplusplus)
-
 #include <memory>
 
 // lldb forward declarations
 namespace lldb_private {
 
 class ABI;
 class ASTResultSynthesizer;
 class ASTStructExtractor;

 typedef std::shared_ptr<lldb_private::Value> ValueSP;
 typedef std::shared_ptr<lldb_private::Variable> VariableSP;
 typedef std::shared_ptr<lldb_private::VariableList> VariableListSP;
 typedef std::shared_ptr<lldb_private::ValueObjectList> ValueObjectListSP;
 typedef std::shared_ptr<lldb_private::Watchpoint> WatchpointSP;
 
 } // namespace lldb
 
-#endif // #if defined(__cplusplus)
 #endif // LLDB_LLDB_FORWARD_H

lldb/include/lldb/lldb-private-interfaces.h

 //===-- lldb-private-interfaces.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 LLDB_LLDB_PRIVATE_INTERFACES_H
 #define LLDB_LLDB_PRIVATE_INTERFACES_H
 
-#if defined(__cplusplus)
-
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-types.h"
 #include <memory>
 #include <set>
 
 namespace llvm {

 typedef llvm::Expected<lldb::TraceSP> (*TraceCreateInstanceForLiveProcess)(
     Process &process);
 typedef llvm::Expected<lldb::TraceExporterUP> (*TraceExporterCreateInstance)();
 typedef lldb::CommandObjectSP (*ThreadTraceExportCommandCreator)(
     CommandInterpreter &interpreter);
 /// \}
 } // namespace lldb_private
 
-#endif // #if defined(__cplusplus)
-
 #endif // LLDB_LLDB_PRIVATE_INTERFACES_H

lldb/include/lldb/lldb-private-types.h

 //===-- lldb-private-types.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 LLDB_LLDB_PRIVATE_TYPES_H
 #define LLDB_LLDB_PRIVATE_TYPES_H
 
-#if defined(__cplusplus)
-
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 #include <type_traits>
 
 namespace llvm {
 namespace sys {
using ValueObjectProviderTy =
     std::function<lldb::ValueObjectSP(ConstString, StackFrame *)>;
 
 typedef void (*DebuggerDestroyCallback)(lldb::user_id_t debugger_id,
                                         void *baton);
 typedef bool (*CommandOverrideCallbackWithResult)(
     void *baton, const char **argv, lldb_private::CommandReturnObject &result);
 } // namespace lldb_private
 
-#endif // #if defined(__cplusplus)
-
 #endif // LLDB_LLDB_PRIVATE_TYPES_H

lldb/include/lldb/lldb-private.h

 //===-- lldb-private.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 LLDB_LLDB_PRIVATE_H
 #define LLDB_LLDB_PRIVATE_H
 
-#if defined(__cplusplus)
-
 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-private-interfaces.h"
 #include "lldb/lldb-private-types.h"
 #include "lldb/lldb-public.h"
 
-#endif // defined(__cplusplus)
-
 #endif // LLDB_LLDB_PRIVATE_H

lldb/source/Host/macosx/cfcpp/CFCReleaser.h

 //===-- CFCReleaser.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 LLDB_SOURCE_HOST_MACOSX_CFCPP_CFCRELEASER_H
 #define LLDB_SOURCE_HOST_MACOSX_CFCPP_CFCRELEASER_H
 
 #include <CoreFoundation/CoreFoundation.h>
 
-#ifdef __cplusplus
-
 #include <cassert>
 
 // Templatized CF helper class that can own any CF pointer and will
 // call CFRelease() on any valid pointer it owns unless that pointer is
 // explicitly released using the release() member function. This class
 // is designed to mimic the std::auto_ptr<T> class and has all of the
 // same functions. The one thing to watch out for is the
 // CFCReleaser<T>::release() function won't actually CFRelease any owned
T release() {
     _ptr = NULL;
     return tmp;
   }
 
 private:
   T _ptr;
 };
 
-#endif // #ifdef __cplusplus
 #endif // LLDB_SOURCE_HOST_MACOSX_CFCPP_CFCRELEASER_H

lldb/source/Host/macosx/objcxx/PosixSpawnResponsible.h

 static inline int setup_posix_spawn_responsible_flag(posix_spawnattr_t *attr) {
   if (@available(macOS 10.14, *)) {
 #if __has_include(<responsibility.h>)
     static __typeof__(responsibility_spawnattrs_setdisclaim)
         *responsibility_spawnattrs_setdisclaim_ptr;
     static dispatch_once_t pred;
     dispatch_once(&pred, ^{
       responsibility_spawnattrs_setdisclaim_ptr =
-#ifdef __cplusplus
           reinterpret_cast<__typeof__(&responsibility_spawnattrs_setdisclaim)>
-#endif
           (dlsym(RTLD_DEFAULT, "responsibility_spawnattrs_setdisclaim"));
     });
     if (responsibility_spawnattrs_setdisclaim_ptr)
       return responsibility_spawnattrs_setdisclaim_ptr(attr, true);
 #endif
   }
   return 0;
 }
 
 #endif // LLDB_HOST_POSIXSPAWNRESPONSIBLE_H

lldb/tools/debugserver/source/DNBLog.h

 
 #ifndef LLDB_TOOLS_DEBUGSERVER_SOURCE_DNBLOG_H
 #define LLDB_TOOLS_DEBUGSERVER_SOURCE_DNBLOG_H
 
 #include "DNBDefs.h"
 #include <cstdint>
 #include <cstdio>
 
-#ifdef __cplusplus
 extern "C" {
-#endif
 
 // Flags that get filled in automatically before calling the log callback
 // function
 #define DNBLOG_FLAG_FATAL (1u << 0)
 #define DNBLOG_FLAG_ERROR (1u << 1)
 #define DNBLOG_FLAG_WARNING (1u << 2)
 #define DNBLOG_FLAG_DEBUG (1u << 3)
 #define DNBLOG_FLAG_VERBOSE (1u << 4)

 #define DNBLogCheckLogBit(bit) ((bool)false)
 #define DNBLogSetLogMask(mask) ((uint32_t)0u)
 #define DNBLogGetLogMask() ((uint32_t)0u)
 #define DNBLogToASL() ((void)0)
 #define DNBLogToFile() ((void)0)
 #define DNBLogCloseLogFile() ((void)0)
 
 #endif // #else defined(DNBLOG_ENABLED)
-
-#ifdef __cplusplus
 }
-#endif
 
 #endif // LLDB_TOOLS_DEBUGSERVER_SOURCE_DNBLOG_H

lldb/tools/debugserver/source/DNBRegisterInfo.h

 #ifndef LLDB_TOOLS_DEBUGSERVER_SOURCE_DNBREGISTERINFO_H
 #define LLDB_TOOLS_DEBUGSERVER_SOURCE_DNBREGISTERINFO_H
 
 #include "DNBDefs.h"
 #include <cstdint>
 #include <cstdio>
 
 struct DNBRegisterValueClass : public DNBRegisterValue {
-#ifdef __cplusplus
   DNBRegisterValueClass(const DNBRegisterInfo *regInfo = NULL);
   void Clear();
   void Dump(const char *pre, const char *post) const;
   bool IsValid() const;
-#endif
 };
 
 #endif

lldb/tools/debugserver/source/MacOSX/CFUtils.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TOOLS_DEBUGSERVER_SOURCE_MACOSX_CFUTILS_H
 #define LLDB_TOOLS_DEBUGSERVER_SOURCE_MACOSX_CFUTILS_H
 
 #include <CoreFoundation/CoreFoundation.h>
 
-#ifdef __cplusplus
-
 // Templatized CF helper class that can own any CF pointer and will
 // call CFRelease() on any valid pointer it owns unless that pointer is
 // explicitly released using the release() member function.
 template <class T> class CFReleaser {
 public:
   // Type names for the value
   typedef T element_type;
 
T release() {
     _ptr = NULL;
     return tmp;
   }
 
 private:
   element_type _ptr;
 };
 
-#endif // #ifdef __cplusplus
 #endif // LLDB_TOOLS_DEBUGSERVER_SOURCE_MACOSX_CFUTILS_H