typedef enum -> enum

[labath]

Thanks. We should have done this a long time ago.

tools/debugserver/source/DNBError.h

40

superfluous space

[MaskRay]

clang format

include/lldb/Breakpoint/Breakpoint.h

 /// tests are done by the location, not by the breakpoint.
 class Breakpoint : public std::enable_shared_from_this<Breakpoint>,
                    public Stoppoint {
 public:
   static ConstString GetEventIdentifier();
 
   /// An enum specifying the match style for breakpoint settings.  At present
   /// only used for function name style breakpoints.
-  typedef enum { Exact, Regexp, Glob } MatchType;
+  enum MatchType { Exact, Regexp, Glob };
 
 private:
   enum class OptionNames : uint32_t { Names = 0, Hardware, LastOptionName };
 
   static const char
       *g_option_names[static_cast<uint32_t>(OptionNames::LastOptionName)];
 
   static const char *GetKey(OptionNames enum_value) {

include/lldb/Core/Address.h

 /// receives notification that shared libraries have been loaded/unloaded, the
 /// load addresses of the main executable and any images (shared libraries)
 /// will be  resolved/unresolved. When this happens, breakpoints that are in
 /// one of these sections can be set/cleared.
 class Address {
 public:
   /// Dump styles allow the Address::Dump(Stream *,DumpStyle) const function
   /// to display Address contents in a variety of ways.
-  typedef enum {
+  enum DumpStyle {
     DumpStyleInvalid,           ///< Invalid dump style
     DumpStyleSectionNameOffset, ///< Display as the section name + offset.
                                 ///< \code
     /// // address for printf in libSystem.B.dylib as a section name + offset
     /// libSystem.B.dylib.__TEXT.__text + 0x0005cfdf \endcode
     DumpStyleSectionPointerOffset, ///< Display as the section pointer + offset
                                    ///(debug output).
                                    ///< \code
DumpStyleNoFunctionName, ///< Elide the function name; display an offset
                              ///into the current function.
                              ///< Used primarily in disassembly symbolication
     DumpStyleDetailedSymbolContext, ///< Detailed symbol context information for
                                     ///an address for all symbol
                                     ///< context members.
     DumpStyleResolvedPointerDescription ///< Dereference a pointer at the
                                         ///current address and then lookup the
     ///< dereferenced address using DumpStyleResolvedDescription
-  } DumpStyle;
+  };
 
   /// Default constructor.
   ///
   /// Initialize with a invalid section (NULL) and an invalid offset
   /// (LLDB_INVALID_ADDRESS).
   Address() : m_section_wp(), m_offset(LLDB_INVALID_ADDRESS) {}
 
   /// Copy constructor

include/lldb/Core/AddressResolver.h

 /// General Outline:
 /// The AddressResolver is a Searcher.  In that protocol, the SearchFilter
 /// asks the question "At what depth of the symbol context descent do you want
 /// your callback to get called?" of the filter.  The resolver answers this
 /// question (in the GetDepth method) and provides the resolution callback.
 
 class AddressResolver : public Searcher {
 public:
-  typedef enum { Exact, Regexp, Glob } MatchType;
+  enum MatchType { Exact, Regexp, Glob };
 
   AddressResolver();
 
   ~AddressResolver() override;
 
   virtual void ResolveAddress(SearchFilter &filter);
 
   virtual void ResolveAddressInModules(SearchFilter &filter,

include/lldb/Core/SearchFilter.h

 /// driven by the SearchFilter to search the SymbolContext space of the target
 /// program.
 
 /// General Outline:
 /// Provides the callback and search depth for the SearchFilter search.
 
 class Searcher {
 public:
-  typedef enum {
+  enum CallbackReturn {
     eCallbackReturnStop = 0, // Stop the iteration
     eCallbackReturnContinue, // Continue the iteration
     eCallbackReturnPop       // Pop one level up and continue iterating
-  } CallbackReturn;
+  };
 
   Searcher();
 
   virtual ~Searcher();
 
   virtual CallbackReturn SearchCallback(SearchFilter &filter,
                                         SymbolContext &context, Address *addr,
                                         bool complete) = 0;

include/lldb/Host/Socket.h

 #if defined(_MSC_VER)
 typedef SOCKET NativeSocket;
 #else
 typedef int NativeSocket;
 #endif
 
 class Socket : public IOObject {
 public:
-  typedef enum {
+  enum SocketProtocol {
     ProtocolTcp,
     ProtocolUdp,
     ProtocolUnixDomain,
     ProtocolUnixAbstract
-  } SocketProtocol;
+  };
 
   static const NativeSocket kInvalidSocketValue;
 
   ~Socket() override;
 
   static llvm::Error Initialize();
   static void Terminate();
 

include/lldb/Interpreter/CommandCompletions.h

 public:
   // This is the command completion callback that is used to complete the
   // argument of the option it is bound to (in the OptionDefinition table
   // below).  Return the total number of matches.
   typedef int (*CompletionCallback)(CommandInterpreter &interpreter,
                                     CompletionRequest &request,
                                     // A search filter to limit the search...
                                     lldb_private::SearchFilter *searcher);
-  typedef enum {
+  enum CommonCompletionTypes {
     eNoCompletion = 0u,
     eSourceFileCompletion = (1u << 0),
     eDiskFileCompletion = (1u << 1),
     eDiskDirectoryCompletion = (1u << 2),
     eSymbolCompletion = (1u << 3),
     eModuleCompletion = (1u << 4),
     eSettingsNameCompletion = (1u << 5),
     ePlatformPluginCompletion = (1u << 6),
     eArchitectureCompletion = (1u << 7),
     eVariablePathCompletion = (1u << 8),
     // This item serves two purposes.  It is the last element in the enum, so
     // you can add custom enums starting from here in your Option class. Also
     // if you & in this bit the base code will not process the option.
     eCustomCompletion = (1u << 9)
-  } CommonCompletionTypes;
+  };
 
   struct CommonCompletionElement {
     uint32_t type;
     CompletionCallback callback;
   };
 
   static bool InvokeCommonCompletionCallbacks(
       CommandInterpreter &interpreter, uint32_t completion_mask,

include/lldb/Interpreter/OptionGroupWatchpoint.h

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                         ExecutionContext *execution_context) override;
   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   // Note:
   // eWatchRead == LLDB_WATCH_TYPE_READ; and
   // eWatchWrite == LLDB_WATCH_TYPE_WRITE
-  typedef enum WatchType {
+  enum WatchType {
     eWatchInvalid = 0,
     eWatchRead,
     eWatchWrite,
     eWatchReadWrite
-  } WatchType;
+  };
 
   WatchType watch_type;
   uint32_t watch_size;
   bool watch_type_specified;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(OptionGroupWatchpoint);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionGroupWatchpoint_h_

include/lldb/Interpreter/OptionValue.h

 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-private-interfaces.h"
 
 namespace lldb_private {
 
 // OptionValue
 class OptionValue {
 public:
-  typedef enum {
+  enum Type {
     eTypeInvalid = 0,
     eTypeArch,
     eTypeArgs,
     eTypeArray,
     eTypeBoolean,
     eTypeChar,
     eTypeDictionary,
     eTypeEnum,
     eTypeFileSpec,
     eTypeFileSpecList,
     eTypeFormat,
     eTypeLanguage,
     eTypePathMap,
     eTypeProperties,
     eTypeRegex,
     eTypeSInt64,
     eTypeString,
     eTypeUInt64,
     eTypeUUID,
     eTypeFormatEntity
-  } Type;
+  };
 
   enum {
     eDumpOptionName = (1u << 0),
     eDumpOptionType = (1u << 1),
     eDumpOptionValue = (1u << 2),
     eDumpOptionDescription = (1u << 3),
     eDumpOptionRaw = (1u << 4),
     eDumpOptionCommand = (1u << 5),

include/lldb/Interpreter/ScriptInterpreter.h

public:
   virtual ~ScriptInterpreterLocker() = default;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ScriptInterpreterLocker);
 };
 
 class ScriptInterpreter : public PluginInterface {
 public:
-  typedef enum {
+  enum ScriptReturnType {
     eScriptReturnTypeCharPtr,
     eScriptReturnTypeBool,
     eScriptReturnTypeShortInt,
     eScriptReturnTypeShortIntUnsigned,
     eScriptReturnTypeInt,
     eScriptReturnTypeIntUnsigned,
     eScriptReturnTypeLongInt,
     eScriptReturnTypeLongIntUnsigned,
     eScriptReturnTypeLongLong,
     eScriptReturnTypeLongLongUnsigned,
     eScriptReturnTypeFloat,
     eScriptReturnTypeDouble,
     eScriptReturnTypeChar,
     eScriptReturnTypeCharStrOrNone,
     eScriptReturnTypeOpaqueObject
-  } ScriptReturnType;
+  };
 
   ScriptInterpreter(Debugger &debugger, lldb::ScriptLanguage script_lang);
 
   ~ScriptInterpreter() override;
 
   struct ExecuteScriptOptions {
   public:
     ExecuteScriptOptions()

include/lldb/Symbol/ObjectFile.h

 /// Once an architecture is selected the object file information can be
 /// extracted from this abstract class.
 class ObjectFile : public std::enable_shared_from_this<ObjectFile>,
                    public PluginInterface,
                    public ModuleChild {
   friend class lldb_private::Module;
 
 public:
-  typedef enum {
+  enum Type {
     eTypeInvalid = 0,
     eTypeCoreFile,      /// A core file that has a checkpoint of a program's
                         /// execution state
     eTypeExecutable,    /// A normal executable
     eTypeDebugInfo,     /// An object file that contains only debug information
     eTypeDynamicLinker, /// The platform's dynamic linker executable
     eTypeObjectFile,    /// An intermediate object file
     eTypeSharedLibrary, /// A shared library that can be used during execution
     eTypeStubLibrary, /// A library that can be linked against but not used for
                       /// execution
     eTypeJIT, /// JIT code that has symbols, sections and possibly debug info
     eTypeUnknown
-  } Type;
+  };
 
-  typedef enum {
+  enum Strata {
     eStrataInvalid = 0,
     eStrataUnknown,
     eStrataUser,
     eStrataKernel,
     eStrataRawImage,
     eStrataJIT
-  } Strata;
+  };
 
   struct LoadableData {
     lldb::addr_t Dest;
     llvm::ArrayRef<uint8_t> Contents;
   };
 
   /// Construct with a parent module, offset, and header data.
   ///

include/lldb/Symbol/SymbolContext.h

public:
   Block *block;             ///< The Block for a given query
   LineEntry line_entry;     ///< The LineEntry for a given query
   Symbol *symbol;           ///< The Symbol for a given query
   Variable *variable;       ///< The global variable matching the given query
 };
 
 class SymbolContextSpecifier {
 public:
-  typedef enum SpecificationType {
+  enum SpecificationType {
     eNothingSpecified = 0,
     eModuleSpecified = 1 << 0,
     eFileSpecified = 1 << 1,
     eLineStartSpecified = 1 << 2,
     eLineEndSpecified = 1 << 3,
     eFunctionSpecified = 1 << 4,
     eClassOrNamespaceSpecified = 1 << 5,
     eAddressRangeSpecified = 1 << 6
-  } SpecificationType;
+  };
 
   // This one produces a specifier that matches everything...
   SymbolContextSpecifier(const lldb::TargetSP &target_sp);
 
   ~SymbolContextSpecifier();
 
   bool AddSpecification(const char *spec_string, SpecificationType type);
 

include/lldb/Symbol/Symtab.h

 
 namespace lldb_private {
 
 class Symtab {
 public:
   typedef std::vector<uint32_t> IndexCollection;
   typedef UniqueCStringMap<uint32_t> NameToIndexMap;
 
-  typedef enum Debug {
+  enum Debug {
     eDebugNo,  // Not a debug symbol
     eDebugYes, // A debug symbol
     eDebugAny
-  } Debug;
+  };
 
-  typedef enum Visibility {
+  enum Visibility {
     eVisibilityAny,
     eVisibilityExtern,
     eVisibilityPrivate
-  } Visibility;
+  };
 
   Symtab(ObjectFile *objfile);
   ~Symtab();
 
   void PreloadSymbols();
   void Reserve(size_t count);
   Symbol *Resize(size_t count);
   uint32_t AddSymbol(const Symbol &symbol);

include/lldb/Symbol/Type.h

 
 protected:
   SymbolFile &m_symbol_file;
   lldb::TypeSP m_type_sp;
 };
 
 class Type : public std::enable_shared_from_this<Type>, public UserID {
 public:
-  typedef enum EncodingDataTypeTag {
+  enum EncodingDataType {
     eEncodingInvalid,
     eEncodingIsUID,      ///< This type is the type whose UID is m_encoding_uid
     eEncodingIsConstUID, ///< This type is the type whose UID is m_encoding_uid
                          ///with the const qualifier added
     eEncodingIsRestrictUID, ///< This type is the type whose UID is
                             ///m_encoding_uid with the restrict qualifier added
     eEncodingIsVolatileUID, ///< This type is the type whose UID is
                             ///m_encoding_uid with the volatile qualifier added
     eEncodingIsTypedefUID,  ///< This type is pointer to a type whose UID is
                             ///m_encoding_uid
     eEncodingIsPointerUID,  ///< This type is pointer to a type whose UID is
                             ///m_encoding_uid
     eEncodingIsLValueReferenceUID, ///< This type is L value reference to a type
                                    ///whose UID is m_encoding_uid
     eEncodingIsRValueReferenceUID, ///< This type is R value reference to a type
                                    ///whose UID is m_encoding_uid
     eEncodingIsSyntheticUID
-  } EncodingDataType;
+  };
 
   // We must force the underlying type of the enum to be unsigned here.  Not
   // all compilers behave the same with regards to the default underlying type
   // of an enum, but because this enum is used in an enum bitfield and integer
   // comparisons are done with the value we need to guarantee that it's always
   // unsigned so that, for example, eResolveStateFull doesn't compare less than
   // eResolveStateUnresolved when used in a 2-bit bitfield.
   typedef enum ResolveStateTag : unsigned {

include/lldb/Target/Process.h

protected:
   // action allowed in the process at one time.  If a new "NextEventAction" is
   // added while one is already present, the old action will be discarded (with
   // HandleBeingUnshipped called after it is discarded.)
   //
   // If you want to resume the process as a result of a resume action, call
   // RequestResume, don't call Resume directly.
   class NextEventAction {
   public:
-    typedef enum EventActionResult {
+    enum EventActionResult {
       eEventActionSuccess,
       eEventActionRetry,
       eEventActionExit
-    } EventActionResult;
+    };
 
     NextEventAction(Process *process) : m_process(process) {}
 
     virtual ~NextEventAction() = default;
 
     virtual EventActionResult PerformAction(lldb::EventSP &event_sp) = 0;
     virtual void HandleBeingUnshipped() {}
     virtual EventActionResult HandleBeingInterrupted() = 0;

include/lldb/Target/Target.h

 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Timeout.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
 OptionEnumValues GetDynamicValueTypes();
 
-typedef enum InlineStrategy {
+enum InlineStrategy {
   eInlineBreakpointsNever = 0,
   eInlineBreakpointsHeaders,
   eInlineBreakpointsAlways
-} InlineStrategy;
+};
 
-typedef enum LoadScriptFromSymFile {
+enum LoadScriptFromSymFile {
   eLoadScriptFromSymFileTrue,
   eLoadScriptFromSymFileFalse,
   eLoadScriptFromSymFileWarn
-} LoadScriptFromSymFile;
+};
 
-typedef enum LoadCWDlldbinitFile {
+enum LoadCWDlldbinitFile {
   eLoadCWDlldbinitTrue,
   eLoadCWDlldbinitFalse,
   eLoadCWDlldbinitWarn
-} LoadCWDlldbinitFile;
+};
 
-typedef enum LoadDependentFiles {
+enum LoadDependentFiles {
   eLoadDependentsDefault,
   eLoadDependentsYes,
   eLoadDependentsNo,
-} LoadDependentFiles;
+};
 
 // TargetProperties
 class TargetExperimentalProperties : public Properties {
 public:
   TargetExperimentalProperties();
 };
 
 class TargetProperties : public Properties {

include/lldb/Target/ThreadPlan.h

 //  The run_vote argument to the constructor works like stop_vote, and is a way
 //  for a plan to instruct a sub-plan
 //  on how to respond to ShouldReportStop.
 //
 
 class ThreadPlan : public std::enable_shared_from_this<ThreadPlan>,
                    public UserID {
 public:
-  typedef enum { eAllThreads, eSomeThreads, eThisThread } ThreadScope;
+  enum ThreadScope { eAllThreads, eSomeThreads, eThisThread };
 
   // We use these enums so that we can cast a base thread plan to it's real
   // type without having to resort to dynamic casting.
-  typedef enum {
+  enum ThreadPlanKind {
     eKindGeneric,
     eKindNull,
     eKindBase,
     eKindCallFunction,
     eKindPython,
     eKindStepInstruction,
     eKindStepOut,
     eKindStepOverBreakpoint,
     eKindStepOverRange,
     eKindStepInRange,
     eKindRunToAddress,
     eKindStepThrough,
     eKindStepUntil,
     eKindTestCondition
 
-  } ThreadPlanKind;
+  };
 
   // Constructors and Destructors
   ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread,
              Vote stop_vote, Vote run_vote);
 
   virtual ~ThreadPlan();
 
   /// Returns the name of this thread plan.

include/lldb/Target/ThreadPlanTracer.h

 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class ThreadPlanTracer {
   friend class ThreadPlan;
 
 public:
-  typedef enum ThreadPlanTracerStyle {
+  enum ThreadPlanTracerStyle {
     eLocation = 0,
     eStateChange,
     eCheckFrames,
     ePython
-  } ThreadPlanTracerStyle;
+  };
 
   ThreadPlanTracer(Thread &thread, lldb::StreamSP &stream_sp);
   ThreadPlanTracer(Thread &thread);
 
   virtual ~ThreadPlanTracer() = default;
 
   virtual void TracingStarted() {}
 

include/lldb/Utility/DataExtractor.h

 /// unique position in the shared data and extract data from different
 /// offsets.
 ///
 /// \see DataBuffer
 class DataExtractor {
 public:
   /// \typedef DataExtractor::Type
   /// Type enumerations used in the dump routines.
-  typedef enum {
+  enum Type {
     TypeUInt8,   ///< Format output as unsigned 8 bit integers
     TypeChar,    ///< Format output as characters
     TypeUInt16,  ///< Format output as unsigned 16 bit integers
     TypeUInt32,  ///< Format output as unsigned 32 bit integers
     TypeUInt64,  ///< Format output as unsigned 64 bit integers
     TypePointer, ///< Format output as pointers
     TypeULEB128, ///< Format output as ULEB128 numbers
     TypeSLEB128  ///< Format output as SLEB128 numbers
-  } Type;
+  };
 
   /// Default constructor.
   ///
   /// Initialize all members to a default empty state.
   DataExtractor();
 
   /// Construct with a buffer that is owned by the caller.
   ///

include/lldb/Utility/IOObject.h

 #include <sys/types.h>
 
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class IOObject {
 public:
-  typedef enum {
+  enum FDType {
     eFDTypeFile,   // Other FD requiring read/write
     eFDTypeSocket, // Socket requiring send/recv
-  } FDType;
+  };
 
   // TODO: On Windows this should be a HANDLE, and wait should use
   // WaitForMultipleObjects
   typedef int WaitableHandle;
   static const WaitableHandle kInvalidHandleValue;
 
   IOObject(FDType type, bool should_close)
       : m_fd_type(type), m_should_close_fd(should_close) {}

include/lldb/Utility/Predicate.h

 #include "lldb/Utility/Timeout.h"
 #include "lldb/lldb-defines.h"
 
 //#define DB_PTHREAD_LOG_EVENTS
 
 /// Enumerations for broadcasting.
 namespace lldb_private {
 
-typedef enum {
+enum PredicateBroadcastType {
   eBroadcastNever,   ///< No broadcast will be sent when the value is modified.
   eBroadcastAlways,  ///< Always send a broadcast when the value is modified.
   eBroadcastOnChange ///< Only broadcast if the value changes when the value is
                      /// modified.
-} PredicateBroadcastType;
+};
 
 /// \class Predicate Predicate.h "lldb/Utility/Predicate.h"
 /// A C++ wrapper class for providing threaded access to a value of
 /// type T.
 ///
 /// A templatized class that provides multi-threaded access to a value
 /// of type T. Threads can efficiently wait for bits within T to be set
 /// or reset, or wait for T to be set to be equal/not equal to a

include/lldb/lldb-private-enumerations.h

 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FormatProviders.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lldb_private {
 
 // Thread Step Types
-typedef enum StepType {
+enum StepType {
   eStepTypeNone,
   eStepTypeTrace,     ///< Single step one instruction.
   eStepTypeTraceOver, ///< Single step one instruction, stepping over.
   eStepTypeInto,      ///< Single step into a specified context.
   eStepTypeOver,      ///< Single step over a specified context.
   eStepTypeOut,       ///< Single step out a specified context.
   eStepTypeScripted   ///< A step type implemented by the script interpreter.
-} StepType;
+};
 
 // Address Types
-typedef enum AddressType {
+enum AddressType {
   eAddressTypeInvalid = 0,
   eAddressTypeFile, ///< Address is an address as found in an object or symbol
                     ///file
   eAddressTypeLoad, ///< Address is an address as in the current target inferior
                     ///process
   eAddressTypeHost  ///< Address is an address in the process that is running
                     ///this code
-} AddressType;
+};
 
 // Address Class
 //
 // A way of classifying an address used for disassembling and setting
 // breakpoints. Many object files can track exactly what parts of their object
 // files are code, data and other information. This is of course above and
 // beyond just looking at the section types. For example, code might contain PC
 // relative data and the object file might be able to tell us that an address
 // in code is data.
 enum class AddressClass {
   eInvalid,
   eUnknown,
   eCode,
   eCodeAlternateISA,
   eData,
   eDebug,
   eRuntime
 };
 
 // Votes - Need a tri-state, yes, no, no opinion...
-typedef enum Vote { eVoteNo = -1, eVoteNoOpinion = 0, eVoteYes = 1 } Vote;
+enum Vote { eVoteNo = -1, eVoteNoOpinion = 0, eVoteYes = 1 };
 
-typedef enum ArchitectureType {
+enum ArchitectureType {
   eArchTypeInvalid,
   eArchTypeMachO,
   eArchTypeELF,
   eArchTypeCOFF,
   kNumArchTypes
-} ArchitectureType;
+};
 
 /// Settable state variable types.
 ///
 
 // typedef enum SettableVariableType
 //{
 //    eSetVarTypeInt,
 //    eSetVarTypeBoolean,
 //    eSetVarTypeString,
 //    eSetVarTypeArray,
 //    eSetVarTypeDictionary,
 //    eSetVarTypeEnum,
 //    eSetVarTypeNone
 //} SettableVariableType;
 
-typedef enum VarSetOperationType {
+enum VarSetOperationType {
   eVarSetOperationReplace,
   eVarSetOperationInsertBefore,
   eVarSetOperationInsertAfter,
   eVarSetOperationRemove,
   eVarSetOperationAppend,
   eVarSetOperationClear,
   eVarSetOperationAssign,
   eVarSetOperationInvalid
-} VarSetOperationType;
+};
 
-typedef enum ArgumentRepetitionType {
+enum ArgumentRepetitionType {
   eArgRepeatPlain,        // Exactly one occurrence
   eArgRepeatOptional,     // At most one occurrence, but it's optional
   eArgRepeatPlus,         // One or more occurrences
   eArgRepeatStar,         // Zero or more occurrences
   eArgRepeatRange,        // Repetition of same argument, from 1 to n
   eArgRepeatPairPlain,    // A pair of arguments that must always go together
                           // ([arg-type arg-value]), occurs exactly once
   eArgRepeatPairOptional, // A pair that occurs at most once (optional)
   eArgRepeatPairPlus,     // One or more occurrences of a pair
   eArgRepeatPairStar,     // Zero or more occurrences of a pair
   eArgRepeatPairRange,    // A pair that repeats from 1 to n
   eArgRepeatPairRangeOptional // A pair that repeats from 1 to n, but is
                               // optional
-} ArgumentRepetitionType;
+};
 
-typedef enum SortOrder {
+enum SortOrder {
   eSortOrderNone,
   eSortOrderByAddress,
   eSortOrderByName
-} SortOrder;
+};
 
 // LazyBool is for boolean values that need to be calculated lazily. Values
 // start off set to eLazyBoolCalculate, and then they can be calculated once
 // and set to eLazyBoolNo or eLazyBoolYes.
-typedef enum LazyBool {
+enum LazyBool {
   eLazyBoolCalculate = -1,
   eLazyBoolNo = 0,
   eLazyBoolYes = 1
-} LazyBool;
+};
 
 /// Instruction types
-typedef enum InstructionType {
+enum InstructionType {
   eInstructionTypeAny, // Support for any instructions at all (at least one)
   eInstructionTypePrologueEpilogue, // All prologue and epilogue instructions
                                     // that push and pop register values and
                                     // modify sp/fp
   eInstructionTypePCModifying,      // Any instruction that modifies the program
                                     // counter/instruction pointer
   eInstructionTypeAll               // All instructions of any kind
 
-} InstructionType;
+};
 
 /// Format category entry types
-typedef enum FormatCategoryItem {
+enum FormatCategoryItem {
   eFormatCategoryItemSummary = 0x0001,
   eFormatCategoryItemRegexSummary = 0x0002,
   eFormatCategoryItemFilter = 0x0004,
   eFormatCategoryItemRegexFilter = 0x0008,
   eFormatCategoryItemSynth = 0x0010,
   eFormatCategoryItemRegexSynth = 0x0020,
   eFormatCategoryItemValue = 0x0040,
   eFormatCategoryItemRegexValue = 0x0080,
   eFormatCategoryItemValidator = 0x0100,
   eFormatCategoryItemRegexValidator = 0x0200
-} FormatCategoryItem;
+};
 
 /// Expression execution policies
-typedef enum {
+enum ExecutionPolicy {
   eExecutionPolicyOnlyWhenNeeded,
   eExecutionPolicyNever,
   eExecutionPolicyAlways,
   eExecutionPolicyTopLevel // used for top-level code
-} ExecutionPolicy;
+};
 
 // Ways that the FormatManager picks a particular format for a type
-typedef enum FormatterChoiceCriterion {
+enum FormatterChoiceCriterion {
   eFormatterChoiceCriterionDirectChoice = 0x00000000,
   eFormatterChoiceCriterionStrippedPointerReference = 0x00000001,
   eFormatterChoiceCriterionNavigatedTypedefs = 0x00000002,
   eFormatterChoiceCriterionRegularExpressionSummary = 0x00000004,
   eFormatterChoiceCriterionRegularExpressionFilter = 0x00000004,
   eFormatterChoiceCriterionLanguagePlugin = 0x00000008,
   eFormatterChoiceCriterionStrippedBitField = 0x00000010,
   eFormatterChoiceCriterionWentToStaticValue = 0x00000020
-} FormatterChoiceCriterion;
+};
 
 // Synchronicity behavior of scripted commands
-typedef enum ScriptedCommandSynchronicity {
+enum ScriptedCommandSynchronicity {
   eScriptedCommandSynchronicitySynchronous,
   eScriptedCommandSynchronicityAsynchronous,
   eScriptedCommandSynchronicityCurrentValue // use whatever the current
                                             // synchronicity is
-} ScriptedCommandSynchronicity;
+};
 
 // Verbosity mode of "po" output
-typedef enum LanguageRuntimeDescriptionDisplayVerbosity {
+enum LanguageRuntimeDescriptionDisplayVerbosity {
   eLanguageRuntimeDescriptionDisplayVerbosityCompact, // only print the
                                                       // description string, if
                                                       // any
   eLanguageRuntimeDescriptionDisplayVerbosityFull,    // print the full-blown
                                                       // output
-} LanguageRuntimeDescriptionDisplayVerbosity;
+};
 
 // Loading modules from memory
-typedef enum MemoryModuleLoadLevel {
+enum MemoryModuleLoadLevel {
   eMemoryModuleLoadLevelMinimal,  // Load sections only
   eMemoryModuleLoadLevelPartial,  // Load function bounds but no symbols
   eMemoryModuleLoadLevelComplete, // Load sections and all symbols
-} MemoryModuleLoadLevel;
+};
 
 // Result enums for when reading multiple lines from IOHandlers
 enum class LineStatus {
   Success, // The line that was just edited if good and should be added to the
            // lines
   Status,  // There is an error with the current line and it needs to be
            // re-edited
            // before it can be accepted

packages/Python/lldbsuite/test/expression_command/cast_int_to_anonymous_enum/main.cpp

-typedef enum {
+enum flow_e {
     A=0,
-} flow_e;
+};
 
 int main() {
    flow_e f;
 
    return 0; // break here
 }

packages/Python/lldbsuite/test/python_api/lldbutil/iter/main.cpp

 #include <random>
 #include <thread>
 
 std::thread g_thread_1;
 std::thread g_thread_2;
 std::thread g_thread_3;
 std::mutex g_mask_mutex;
 
-typedef enum {
+enum MaskAction {
     eGet,
     eAssign,
     eClearBits
-} MaskAction;
+};
 
 uint32_t mask_access (MaskAction action, uint32_t mask = 0);
 
 uint32_t
 mask_access (MaskAction action, uint32_t mask)
 {
     static uint32_t g_mask = 0;
 

packages/Python/lldbsuite/test/python_api/module_section/main.cpp

 #include <random>
 #include <thread>
 
 std::thread g_thread_1;
 std::thread g_thread_2;
 std::thread g_thread_3;
 std::mutex g_mask_mutex;
 
-typedef enum {
+enum MaskAction {
     eGet,
     eAssign,
     eClearBits
-} MaskAction;
+};
 
 uint32_t mask_access (MaskAction action, uint32_t mask = 0);
 
 uint32_t
 mask_access (MaskAction action, uint32_t mask)
 {
     static uint32_t g_mask = 0;
 

source/Commands/CommandObjectBreakpoint.cpp

static constexpr OptionDefinition g_breakpoint_set_options[] = {
   "setting is used." },
     // clang-format on
 };
 
 // CommandObjectBreakpointSet
 
 class CommandObjectBreakpointSet : public CommandObjectParsed {
 public:
-  typedef enum BreakpointSetType {
+  enum BreakpointSetType {
     eSetTypeInvalid,
     eSetTypeFileAndLine,
     eSetTypeAddress,
     eSetTypeFunctionName,
     eSetTypeFunctionRegexp,
     eSetTypeSourceRegexp,
     eSetTypeException,
     eSetTypeScripted,
-  } BreakpointSetType;
+  };
 
   CommandObjectBreakpointSet(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "breakpoint set",
             "Sets a breakpoint or set of breakpoints in the executable.",
             "breakpoint set <cmd-options>"),
         m_bp_opts(), m_options() {
           // We're picking up all the normal options, commands and disable.
static constexpr OptionDefinition g_breakpoint_clear_options[] = {
   { LLDB_OPT_SET_1, true,  "line", 'l', OptionParser::eRequiredArgument, nullptr, {}, 0,                                         eArgTypeLineNum,  "Specify the breakpoint by source location at this particular line." }
     // clang-format on
 };
 
 #pragma mark Clear
 
 class CommandObjectBreakpointClear : public CommandObjectParsed {
 public:
-  typedef enum BreakpointClearType {
+  enum BreakpointClearType {
     eClearTypeInvalid,
     eClearTypeFileAndLine
-  } BreakpointClearType;
+  };
 
   CommandObjectBreakpointClear(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "breakpoint clear",
                             "Delete or disable breakpoints matching the "
                             "specified source file and line.",
                             "breakpoint clear <cmd-options>"),
         m_options() {}
 

source/Plugins/Instruction/ARM/EmulateInstructionARM.h

 
 private:
   uint32_t ITCounter; // Possible values: 0, 1, 2, 3, 4.
   uint32_t ITState;   // A2.5.2 Consists of IT[7:5] and IT[4:0] initially.
 };
 
 class EmulateInstructionARM : public EmulateInstruction {
 public:
-  typedef enum {
+  enum ARMEncoding {
     eEncodingA1,
     eEncodingA2,
     eEncodingA3,
     eEncodingA4,
     eEncodingA5,
     eEncodingT1,
     eEncodingT2,
     eEncodingT3,
     eEncodingT4,
     eEncodingT5
-  } ARMEncoding;
+  };
 
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
inline bool MemUWrite(EmulateInstruction::Context &context,
     // the hardware, we can update this function appropriately.
 
     return WriteMemoryUnsigned(context, address, data_val, size);
   }
 
 protected:
   // Typedef for the callback function used during the emulation.
   // Pass along (ARMEncoding)encoding as the callback data.
-  typedef enum { eSize16, eSize32 } ARMInstrSize;
+  enum ARMInstrSize { eSize16, eSize32 };
 
   typedef struct {
     uint32_t mask;
     uint32_t value;
     uint32_t variants;
     EmulateInstructionARM::ARMEncoding encoding;
     uint32_t vfp_variants;
     ARMInstrSize size;

source/Plugins/Instruction/ARM64/EmulateInstructionARM64.h

public:
   }
 
   bool GetRegisterInfo(lldb::RegisterKind reg_kind, uint32_t reg_num,
                        lldb_private::RegisterInfo &reg_info) override;
 
   bool
   CreateFunctionEntryUnwind(lldb_private::UnwindPlan &unwind_plan) override;
 
-  typedef enum { AddrMode_OFF, AddrMode_PRE, AddrMode_POST } AddrMode;
+  enum AddrMode { AddrMode_OFF, AddrMode_PRE, AddrMode_POST };
 
-  typedef enum {
+  enum BranchType {
     BranchType_CALL,
     BranchType_ERET,
     BranchType_DRET,
     BranchType_RET,
     BranchType_JMP
-  } BranchType;
+  };
 
-  typedef enum { CountOp_CLZ, CountOp_CLS, CountOp_CNT } CountOp;
+  enum CountOp { CountOp_CLZ, CountOp_CLS, CountOp_CNT };
 
-  typedef enum { RevOp_RBIT, RevOp_REV16, RevOp_REV32, RevOp_REV64 } RevOp;
+  enum RevOp { RevOp_RBIT, RevOp_REV16, RevOp_REV32, RevOp_REV64 };
 
-  typedef enum { BitwiseOp_NOT, BitwiseOp_RBIT } BitwiseOp;
+  enum BitwiseOp { BitwiseOp_NOT, BitwiseOp_RBIT };
 
-  typedef enum { EL0 = 0, EL1 = 1, EL2 = 2, EL3 = 3 } ExceptionLevel;
+  enum ExceptionLevel { EL0 = 0, EL1 = 1, EL2 = 2, EL3 = 3 };
 
-  typedef enum {
+  enum ExtendType {
     ExtendType_SXTB,
     ExtendType_SXTH,
     ExtendType_SXTW,
     ExtendType_SXTX,
     ExtendType_UXTB,
     ExtendType_UXTH,
     ExtendType_UXTW,
     ExtendType_UXTX
-  } ExtendType;
+  };
 
-  typedef enum { ExtractType_LEFT, ExtractType_RIGHT } ExtractType;
+  enum ExtractType { ExtractType_LEFT, ExtractType_RIGHT };
 
-  typedef enum { LogicalOp_AND, LogicalOp_EOR, LogicalOp_ORR } LogicalOp;
+  enum LogicalOp { LogicalOp_AND, LogicalOp_EOR, LogicalOp_ORR };
 
-  typedef enum { MemOp_LOAD, MemOp_STORE, MemOp_PREFETCH, MemOp_NOP } MemOp;
+  enum MemOp { MemOp_LOAD, MemOp_STORE, MemOp_PREFETCH, MemOp_NOP };
 
-  typedef enum { MoveWideOp_N, MoveWideOp_Z, MoveWideOp_K } MoveWideOp;
+  enum MoveWideOp { MoveWideOp_N, MoveWideOp_Z, MoveWideOp_K };
 
-  typedef enum {
+  enum ShiftType {
     ShiftType_LSL,
     ShiftType_LSR,
     ShiftType_ASR,
     ShiftType_ROR
-  } ShiftType;
+  };
 
-  typedef enum { SP0 = 0, SPx = 1 } StackPointerSelection;
+  enum StackPointerSelection { SP0 = 0, SPx = 1 };
 
-  typedef enum {
+  enum Unpredictable {
     Unpredictable_WBOVERLAP,
     Unpredictable_LDPOVERLAP
-  } Unpredictable;
+  };
 
-  typedef enum {
+  enum ConstraintType {
     Constraint_NONE,
     Constraint_UNKNOWN,
     Constraint_SUPPRESSWB,
     Constraint_NOP
-  } ConstraintType;
+  };
 
-  typedef enum {
+  enum AccType {
     AccType_NORMAL,
     AccType_UNPRIV,
     AccType_STREAM,
     AccType_ALIGNED,
     AccType_ORDERED
-  } AccType;
+  };
 
   typedef struct {
     uint32_t N : 1, V : 1, C : 1,
         Z : 1,  // condition code flags – can also be accessed as
                 // PSTATE.[N,Z,C,V]
         Q : 1,  // AArch32 only – CSPR.Q bit
         IT : 8, // AArch32 only – CPSR.IT bits
         J : 1,  // AArch32 only – CSPR.J bit

source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

 #include "JITLoaderGDB.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 // Debug Interface Structures
-typedef enum {
+enum jit_actions_t {
   JIT_NOACTION = 0,
   JIT_REGISTER_FN,
   JIT_UNREGISTER_FN
-} jit_actions_t;
+};
 
 template <typename ptr_t> struct jit_code_entry {
   ptr_t next_entry;   // pointer
   ptr_t prev_entry;   // pointer
   ptr_t symfile_addr; // pointer
   uint64_t symfile_size;
 };
 

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h

public:
   FunctionCaller *GetLookupImplementationFunctionCaller();
 
   bool AddrIsMsgForward(lldb::addr_t addr) const {
     return (addr == m_msg_forward_addr || addr == m_msg_forward_stret_addr);
   }
 
   struct DispatchFunction {
   public:
-    typedef enum { eFixUpNone, eFixUpFixed, eFixUpToFix } FixUpState;
+    enum FixUpState { eFixUpNone, eFixUpFixed, eFixUpToFix };
 
     const char *name;
     bool stret_return;
     bool is_super;
     bool is_super2;
     FixUpState fixedup;
   };
 

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

 
 #include <vector>
 
 #include "lldb/Symbol/ObjectFile.h"
 #include "llvm/Object/Binary.h"
 
 class ObjectFilePECOFF : public lldb_private::ObjectFile {
 public:
-  typedef enum MachineType {
+  enum MachineType {
     MachineUnknown = 0x0,
     MachineAm33 = 0x1d3,
     MachineAmd64 = 0x8664,
     MachineArm = 0x1c0,
     MachineArmNt = 0x1c4,
     MachineArm64 = 0xaa64,
     MachineEbc = 0xebc,
     MachineX86 = 0x14c,
     MachineIA64 = 0x200,
     MachineM32R = 0x9041,
     MachineMips16 = 0x266,
     MachineMipsFpu = 0x366,
     MachineMipsFpu16 = 0x466,
     MachinePowerPc = 0x1f0,
     MachinePowerPcfp = 0x1f1,
     MachineR4000 = 0x166,
     MachineSh3 = 0x1a2,
     MachineSh3dsp = 0x1a3,
     MachineSh4 = 0x1a6,
     MachineSh5 = 0x1a8,
     MachineThumb = 0x1c2,
     MachineWcemIpsv2 = 0x169
-  } MachineType;
+  };
 
   ObjectFilePECOFF(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
                    lldb::offset_t data_offset,
                    const lldb_private::FileSpec *file,
                    lldb::offset_t file_offset, lldb::offset_t length);
 
   ObjectFilePECOFF(const lldb::ModuleSP &module_sp,
                    lldb::DataBufferSP &header_data_sp,
typedef struct coff_opt_header {
     uint64_t heap_reserve_size;
     uint64_t heap_commit_size;
     uint32_t loader_flags;
     //    uint32_t  num_data_dir_entries;
     std::vector<data_directory>
         data_dirs; // will contain num_data_dir_entries entries
   } coff_opt_header_t;
 
-  typedef enum coff_data_dir_type {
+  enum coff_data_dir_type {
     coff_data_dir_export_table = 0,
     coff_data_dir_import_table = 1,
-  } coff_data_dir_type;
+  };
 
   typedef struct section_header {
     char name[8];
     uint32_t vmsize;  // Virtual Size
     uint32_t vmaddr;  // Virtual Addr
     uint32_t size;    // File size
     uint32_t offset;  // File offset
     uint32_t reloff;  // Offset to relocations

source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h

 
 class CommunicationKDP : public lldb_private::Communication {
 public:
   enum { eBroadcastBitRunPacketSent = kLoUserBroadcastBit };
 
   const static uint32_t kMaxPacketSize = 1200;
   const static uint32_t kMaxDataSize = 1024;
   typedef lldb_private::StreamBuffer<1024> PacketStreamType;
-  typedef enum {
+  enum CommandType {
     KDP_CONNECT = 0u,
     KDP_DISCONNECT,
     KDP_HOSTINFO,
     KDP_VERSION,
     KDP_MAXBYTES,
     KDP_READMEM,
     KDP_WRITEMEM,
     KDP_READREGS,
enum CommandType {
     KDP_KERNELVERSION,
     KDP_READPHYSMEM64,
     KDP_WRITEPHYSMEM64,
     KDP_READIOPORT,
     KDP_WRITEIOPORT,
     KDP_READMSR64,
     KDP_WRITEMSR64,
     KDP_DUMPINFO
-  } CommandType;
+  };
 
   enum { KDP_FEATURE_BP = (1u << 0) };
 
-  typedef enum {
+  enum KDPError {
     KDP_PROTERR_SUCCESS = 0,
     KDP_PROTERR_ALREADY_CONNECTED,
     KDP_PROTERR_BAD_NBYTES,
     KDP_PROTERR_BADFLAVOR
-  } KDPError;
+  };
 
-  typedef enum {
+  enum PacketType {
     ePacketTypeRequest = 0x00u,
     ePacketTypeReply = 0x80u,
     ePacketTypeMask = 0x80u,
     eCommandTypeMask = 0x7fu
-  } PacketType;
+  };
   // Constructors and Destructors
   CommunicationKDP(const char *comm_name);
 
   virtual ~CommunicationKDP();
 
   bool SendRequestPacket(const PacketStreamType &request_packet);
 
   // Wait for a packet within 'nsec' seconds

source/Plugins/Process/Utility/ARMDefines.h

 #include <cassert>
 #include <cstdint>
 
 // Common definitions for the ARM/Thumb Instruction Set Architecture.
 
 namespace lldb_private {
 
 // ARM shifter types
-typedef enum {
+enum ARM_ShifterType {
   SRType_LSL,
   SRType_LSR,
   SRType_ASR,
   SRType_ROR,
   SRType_RRX,
   SRType_Invalid
-} ARM_ShifterType;
+};
 
 // ARM conditions          // Meaning (integer)         Meaning (floating-point)
 // Condition flags
 #define COND_EQ                                                                \
   0x0 // Equal                     Equal                         Z == 1
 #define COND_NE                                                                \
   0x1 // Not equal                 Not equal, or unordered       Z == 0
 #define COND_CS                                                                \

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

 #include "lldb/Utility/Listener.h"
 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 namespace process_gdb_remote {
 
-typedef enum {
+enum GDBStoppointType {
   eStoppointInvalid = -1,
   eBreakpointSoftware = 0,
   eBreakpointHardware,
   eWatchpointWrite,
   eWatchpointRead,
   eWatchpointReadWrite
-} GDBStoppointType;
+};
 
 enum class CompressionType {
   None = 0,    // no compression
   ZlibDeflate, // zlib's deflate compression scheme, requires zlib or Apple's
                // libcompression
   LZFSE,       // an Apple compression scheme, requires Apple's libcompression
   LZ4, // lz compression - called "lz4 raw" in libcompression terms, compat with
        // https://code.google.com/p/lz4/

source/Plugins/Process/mach-core/ProcessMachCore.h

protected:
   bool UpdateThreadList(lldb_private::ThreadList &old_thread_list,
                         lldb_private::ThreadList &new_thread_list) override;
 
   lldb_private::ObjectFile *GetCoreObjectFile();
 
 private:
   bool GetDynamicLoaderAddress(lldb::addr_t addr);
 
-  typedef enum CorefilePreference {
+  enum CorefilePreference {
     eUserProcessCorefile,
     eKernelCorefile
-  } CorefilePreferences;
+  };
 
   /// If a core file can be interpreted multiple ways, this establishes
   /// which style wins.
   ///
   /// If a core file contains both a kernel binary and a user-process
   /// dynamic loader, lldb needs to pick one over the other.  This could
   /// be a kernel corefile that happens to have a copy of dyld in its
   /// memory.  Or it could be a user process coredump of lldb while doing

source/Target/Target.cpp

static constexpr OptionEnumValueElement g_inline_breakpoint_enums[] = {
     {eInlineBreakpointsHeaders, "headers",
      "Only check for inline breakpoint locations when setting breakpoints in "
      "header files, but not when setting breakpoint in implementation source "
      "files (default)."},
     {eInlineBreakpointsAlways, "always",
      "Always look for inline breakpoint locations when setting file and line "
      "breakpoints (slower but most accurate)."} };
 
-typedef enum x86DisassemblyFlavor {
+enum x86DisassemblyFlavor {
   eX86DisFlavorDefault,
   eX86DisFlavorIntel,
   eX86DisFlavorATT
-} x86DisassemblyFlavor;
+};
 
 static constexpr OptionEnumValueElement g_x86_dis_flavor_value_types[] = {
     {eX86DisFlavorDefault, "default", "Disassembler default (currently att)."},
     {eX86DisFlavorIntel, "intel", "Intel disassembler flavor."},
     {eX86DisFlavorATT, "att", "AT&T disassembler flavor."} };
 
 static constexpr OptionEnumValueElement g_hex_immediate_style_values[] = {
     {Disassembler::eHexStyleC, "c", "C-style (0xffff)."},

tools/debugserver/source/DNBDataRef.h

 #include <limits.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 class DNBDataRef {
 public:
   // For use with Dump
-  typedef enum {
+  enum Type {
     TypeUInt8 = 0,
     TypeChar,
     TypeUInt16,
     TypeUInt32,
     TypeUInt64,
     TypePointer,
     TypeULEB128,
     TypeSLEB128
-  } Type;
+  };
   typedef uint32_t offset_t;
   typedef nub_addr_t addr_t;
 
   DNBDataRef();
   DNBDataRef(const uint8_t *start, size_t size, bool swap);
   ~DNBDataRef();
   void Clear() {
     DNBDataRef::SetData(NULL, 0);

tools/debugserver/source/DNBDefs.h

 #define INVALID_NUB_HW_INDEX UINT32_MAX
 #define INVALID_NUB_REGNUM UINT32_MAX
 #define NUB_GENERIC_ERROR UINT32_MAX
 
 // Watchpoint types
 #define WATCH_TYPE_READ (1u << 0)
 #define WATCH_TYPE_WRITE (1u << 1)
 
-typedef enum {
+enum nub_state_t {
   eStateInvalid = 0,
   eStateUnloaded,
   eStateAttaching,
   eStateLaunching,
   eStateStopped,
   eStateRunning,
   eStateStepping,
   eStateCrashed,
   eStateDetached,
   eStateExited,
   eStateSuspended
-} nub_state_t;
+};
 
-typedef enum {
+enum nub_launch_flavor_t {
   eLaunchFlavorDefault = 0,
   eLaunchFlavorPosixSpawn = 1,
   eLaunchFlavorForkExec = 2,
 #ifdef WITH_SPRINGBOARD
   eLaunchFlavorSpringBoard = 3,
 #endif
 #ifdef WITH_BKS
   eLaunchFlavorBKS = 4,
 #endif
 #ifdef WITH_FBS
   eLaunchFlavorFBS = 5
 #endif
-} nub_launch_flavor_t;
+};
 
 #define NUB_STATE_IS_RUNNING(s)                                                \
   ((s) == eStateAttaching || (s) == eStateLaunching || (s) == eStateRunning || \
    (s) == eStateStepping || (s) == eStateDetached)
 
 #define NUB_STATE_IS_STOPPED(s)                                                \
   ((s) == eStateUnloaded || (s) == eStateStopped || (s) == eStateCrashed ||    \
    (s) == eStateExited)

tools/debugserver/source/DNBError.h

 #include <errno.h>
 #include <mach/mach.h>
 #include <stdio.h>
 #include <string>
 
 class DNBError {
 public:
   typedef uint32_t ValueType;
-  typedef enum {
+  enum FlavorType {
     Generic = 0,
     MachKernel = 1,
     POSIX = 2
 #ifdef WITH_SPRINGBOARD
     ,
     SpringBoard = 3
 #endif
 #ifdef WITH_BKS
     ,
     BackBoard = 4
 #endif
 #ifdef WITH_FBS
     ,
     FrontBoard = 5
 #endif
-  } FlavorType;
+  } ;
 
   explicit DNBError(ValueType err = 0, FlavorType flavor = Generic)
       : m_err(err), m_flavor(flavor) {}
 
   const char *AsString() const;
   void Clear() {
     m_err = 0;
     m_flavor = Generic;

tools/debugserver/source/MacOSX/arm/DNBArchImpl.h

#if defined(USE_ARM_DISASSEMBLER_FRAMEWORK)
   void DecodeITBlockInstructions(nub_addr_t curr_pc);
 #endif
   void EvaluateNextInstructionForSoftwareBreakpointSetup(nub_addr_t currentPC,
                                                          uint32_t cpsr,
                                                          bool currentPCIsThumb,
                                                          nub_addr_t *nextPC,
                                                          bool *nextPCIsThumb);
 
-  typedef enum RegisterSetTag {
+  enum RegisterSet {
     e_regSetALL = REGISTER_SET_ALL,
     e_regSetGPR, // ARM_THREAD_STATE
     e_regSetVFP, // ARM_VFP_STATE (ARM_NEON_STATE if defined __arm64__)
     e_regSetEXC, // ARM_EXCEPTION_STATE
     e_regSetDBG, // ARM_DEBUG_STATE (ARM_DEBUG_STATE32 if defined __arm64__)
     kNumRegisterSets
-  } RegisterSet;
+  };
 
   enum { Read = 0, Write = 1, kNumErrors = 2 };
 
   typedef arm_thread_state_t GPR;
 #if defined(__arm64__) || defined(__aarch64__)
   typedef arm_neon_state_t FPU;
 #else
   typedef arm_vfp_state_t FPU;

tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.h

virtual bool DisableHardwareWatchpoint(uint32_t hw_break_index,
                                          bool also_set_on_task);
   virtual bool DisableHardwareWatchpoint_helper(uint32_t hw_break_index,
                                                 bool also_set_on_task);
 
 protected:
   kern_return_t EnableHardwareSingleStep(bool enable);
   static bool FixGenericRegisterNumber(uint32_t &set, uint32_t &reg);
 
-  typedef enum RegisterSetTag {
+  enum RegisterSet {
     e_regSetALL = REGISTER_SET_ALL,
     e_regSetGPR, // ARM_THREAD_STATE64,
     e_regSetVFP, // ARM_NEON_STATE64,
     e_regSetEXC, // ARM_EXCEPTION_STATE64,
     e_regSetDBG, // ARM_DEBUG_STATE64,
     kNumRegisterSets
-  } RegisterSet;
+  };
 
   enum {
     e_regSetGPRCount = ARM_THREAD_STATE64_COUNT,
     e_regSetVFPCount = ARM_NEON_STATE64_COUNT,
     e_regSetEXCCount = ARM_EXCEPTION_STATE64_COUNT,
     e_regSetDBGCount = ARM_DEBUG_STATE64_COUNT,
   };
 

tools/debugserver/source/MacOSX/i386/DNBArchImplI386.h

protected:
   static const size_t k_num_register_sets;
 
   typedef __i386_avx512f_state_t AVX512F;
   static const DNBRegisterInfo g_fpu_registers_avx512f[];
   static const DNBRegisterSetInfo g_reg_sets_avx512f[];
   static const size_t k_num_fpu_registers_avx512f;
   static const size_t k_num_all_registers_avx512f;
 
-  typedef enum RegisterSetTag {
+  enum RegisterSet {
     e_regSetALL = REGISTER_SET_ALL,
     e_regSetGPR,
     e_regSetFPU,
     e_regSetEXC,
     e_regSetDBG,
     kNumRegisterSets
-  } RegisterSet;
+  };
 
-  typedef enum RegisterSetWordSizeTag {
+  enum RegisterSetWordSize {
     e_regSetWordSizeGPR = sizeof(GPR) / sizeof(int),
     e_regSetWordSizeFPU = sizeof(FPU) / sizeof(int),
     e_regSetWordSizeEXC = sizeof(EXC) / sizeof(int),
     e_regSetWordSizeAVX = sizeof(AVX) / sizeof(int),
     e_regSetWordSizeAVX512f = sizeof(AVX512F) / sizeof(int),
     e_regSetWordSizeDBG = sizeof(DBG) / sizeof(int)
-  } RegisterSetWordSize;
+  };
 
   enum { Read = 0, Write = 1, kNumErrors = 2 };
 
   struct Context {
     GPR gpr;
     union {
       FPU no_avx;
       AVX avx;

tools/debugserver/source/MacOSX/ppc/DNBArchImpl.h

public:
   virtual bool ThreadDidStop();
 
   static const uint8_t *SoftwareBreakpointOpcode(nub_size_t byte_size);
   static uint32_t GetCPUType();
 
 protected:
   kern_return_t EnableHardwareSingleStep(bool enable);
 
-  typedef enum RegisterSetTag {
+  enum RegisterSet {
     e_regSetALL = REGISTER_SET_ALL,
     e_regSetGPR,
     e_regSetFPR,
     e_regSetEXC,
     e_regSetVEC,
     kNumRegisterSets
-  } RegisterSet;
+  };
 
   typedef enum RegisterSetWordSizeTag {
     e_regSetWordSizeGPR = PPC_THREAD_STATE_COUNT,
     e_regSetWordSizeFPR = PPC_FLOAT_STATE_COUNT,
     e_regSetWordSizeEXC = PPC_EXCEPTION_STATE_COUNT,
     e_regSetWordSizeVEC = PPC_VECTOR_STATE_COUNT
   } RegisterSetWordSize;
 

tools/debugserver/source/MacOSX/x86_64/DNBArchImplX86_64.h

protected:
   static const size_t k_num_register_sets;
 
   typedef __x86_64_avx512f_state_t AVX512F;
   static const DNBRegisterInfo g_fpu_registers_avx512f[];
   static const DNBRegisterSetInfo g_reg_sets_avx512f[];
   static const size_t k_num_fpu_registers_avx512f;
   static const size_t k_num_all_registers_avx512f;
 
-  typedef enum RegisterSetTag {
+  enum RegisterSet {
     e_regSetALL = REGISTER_SET_ALL,
     e_regSetGPR,
     e_regSetFPU,
     e_regSetEXC,
     e_regSetDBG,
     kNumRegisterSets
-  } RegisterSet;
+  };
 
-  typedef enum RegisterSetWordSizeTag {
+  enum RegisterSetWordSize {
     e_regSetWordSizeGPR = sizeof(GPR) / sizeof(int),
     e_regSetWordSizeFPU = sizeof(FPU) / sizeof(int),
     e_regSetWordSizeEXC = sizeof(EXC) / sizeof(int),
     e_regSetWordSizeAVX = sizeof(AVX) / sizeof(int),
     e_regSetWordSizeAVX512f = sizeof(AVX512F) / sizeof(int),
     e_regSetWordSizeDBG = sizeof(DBG) / sizeof(int)
-  } RegisterSetWordSize;
+  };
 
   enum { Read = 0, Write = 1, kNumErrors = 2 };
 
   struct Context {
     GPR gpr;
     union {
       FPU no_avx;
       AVX avx;

tools/debugserver/source/RNBDefs.h

 
 #error undefined architecture
 
 #endif
 
 class RNBRemote;
 typedef std::shared_ptr<RNBRemote> RNBRemoteSP;
 
-typedef enum { rnb_success = 0, rnb_err = 1, rnb_not_connected = 2 } rnb_err_t;
+enum rnb_err_t { rnb_success = 0, rnb_err = 1, rnb_not_connected = 2 } ;
 
 // Log bits
 // reserve low bits for DNB
 #define LOG_RNB_MINIMAL                                                        \
   ((LOG_LO_USER) << 0) // Minimal logging    (min verbosity)
 #define LOG_RNB_MEDIUM                                                         \
   ((LOG_LO_USER) << 1)                    // Medium logging     (med verbosity)
 #define LOG_RNB_MAX ((LOG_LO_USER) << 2)  // Max logging        (max verbosity)

tools/debugserver/source/RNBRemote.h

 class PThreadEvents;
 
 enum event_loop_mode { debug_nub, gdb_remote_protocol, done };
 
 enum class compression_types { zlib_deflate, lz4, lzma, lzfse, none };
 
 class RNBRemote {
 public:
-  typedef enum {
+  enum PacketEnum {
     invalid_packet = 0,
     ack,                           // '+'
     nack,                          // '-'
     halt,                          // ^C  (async halt)
     use_extended_mode,             // '!'
     why_halted,                    // '?'
     set_argv,                      // 'A'
     set_bp,                        // 'B'
enum PacketEnum {
     save_register_state,                // '_g'
     restore_register_state,             // '_G'
     speed_test,                         // 'qSpeedTest:'
     set_detach_on_error,                // 'QSetDetachOnError:'
     query_transfer,                     // 'qXfer:'
     query_supported_async_json_packets, // 'QSupportedAsyncJSONPackets'
     configure_darwin_log,               // 'ConfigureDarwinLog:'
     unknown_type
-  } PacketEnum;
+  };
 
   typedef rnb_err_t (RNBRemote::*HandlePacketCallback)(const char *p);
 
   RNBRemote();
   ~RNBRemote();
 
   void Initialize();
 

tools/debugserver/source/debugserver.cpp

 #include "RNBServices.h"
 #include "RNBSocket.h"
 #include "SysSignal.h"
 
 // Global PID in case we get a signal and need to stop the process...
 nub_process_t g_pid = INVALID_NUB_PROCESS;
 
 // Run loop modes which determine which run loop function will be called
-typedef enum {
+enum RNBRunLoopMode {
   eRNBRunLoopModeInvalid = 0,
   eRNBRunLoopModeGetStartModeFromRemoteProtocol,
   eRNBRunLoopModeInferiorAttaching,
   eRNBRunLoopModeInferiorLaunching,
   eRNBRunLoopModeInferiorExecuting,
   eRNBRunLoopModePlatformMode,
   eRNBRunLoopModeExit
-} RNBRunLoopMode;
+} ;
 
 // Global Variables
 RNBRemoteSP g_remoteSP;
 static int g_lockdown_opt = 0;
 static int g_applist_opt = 0;
 static nub_launch_flavor_t g_launch_flavor = eLaunchFlavorDefault;
 int g_disable_aslr = 0;
 

tools/debugserver/source/libdebugserver.cpp

 #include "PseudoTerminal.h"
 #include "RNBContext.h"
 #include "RNBRemote.h"
 #include "RNBServices.h"
 #include "RNBSocket.h"
 #include "SysSignal.h"
 
 // Run loop modes which determine which run loop function will be called
-typedef enum {
+enum RNBRunLoopMode {
   eRNBRunLoopModeInvalid = 0,
   eRNBRunLoopModeGetStartModeFromRemoteProtocol,
   eRNBRunLoopModeInferiorExecuting,
   eRNBRunLoopModeExit
-} RNBRunLoopMode;
+};
 
 // Global Variables
 RNBRemoteSP g_remoteSP;
 int g_disable_aslr = 0;
 int g_isatty = 0;
 
 #define RNBLogSTDOUT(fmt, ...)                                                 \
   do {                                                                         \

tools/driver/Driver.h

 #include "llvm/Option/Option.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 class Driver : public lldb::SBBroadcaster {
 public:
-  typedef enum CommandPlacement {
+  enum CommandPlacement {
     eCommandPlacementBeforeFile,
     eCommandPlacementAfterFile,
     eCommandPlacementAfterCrash,
-  } CommandPlacement;
+  };
 
   Driver();
 
   virtual ~Driver();
 
   /// Runs the main loop.
   ///
   /// \return The exit code that the process should return.