| //===-- lldb-enumerations.h -------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLDB_enumerations_h_ |
| #define LLDB_enumerations_h_ |
| |
| namespace lldb { |
| |
| //---------------------------------------------------------------------- |
| // Process and Thread States |
| //---------------------------------------------------------------------- |
| typedef enum StateType |
| { |
| eStateInvalid = 0, |
| eStateUnloaded, ///< Process is object is valid, but not currently loaded |
| eStateConnected, ///< Process is connected to remote debug services, but not launched or attached to anything yet |
| eStateAttaching, ///< Process is currently trying to attach |
| eStateLaunching, ///< Process is in the process of launching |
| eStateStopped, ///< Process or thread is stopped and can be examined. |
| eStateRunning, ///< Process or thread is running and can't be examined. |
| eStateStepping, ///< Process or thread is in the process of stepping and can not be examined. |
| eStateCrashed, ///< Process or thread has crashed and can be examined. |
| eStateDetached, ///< Process has been detached and can't be examined. |
| eStateExited, ///< Process has exited and can't be examined. |
| eStateSuspended ///< Process or thread is in a suspended state as far |
| ///< as the debugger is concerned while other processes |
| ///< or threads get the chance to run. |
| } StateType; |
| |
| //---------------------------------------------------------------------- |
| // Thread Step Types |
| //---------------------------------------------------------------------- |
| typedef 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. |
| } StepType; |
| |
| //---------------------------------------------------------------------- |
| // Launch Flags |
| //---------------------------------------------------------------------- |
| typedef enum LaunchFlags |
| { |
| eLaunchFlagNone = 0u, |
| eLaunchFlagDisableASLR = (1u << 0), ///< Disable Address Space Layout Randomization |
| eLaunchFlagDisableSTDIO = (1u << 1), ///< Disable stdio for inferior process (e.g. for a GUI app) |
| eLaunchFlagLaunchInTTY = (1u << 2) ///< Launch the process in a new TTY if supported by the host |
| } LaunchFlags; |
| |
| //---------------------------------------------------------------------- |
| // Thread Run Modes |
| //---------------------------------------------------------------------- |
| typedef enum RunMode { |
| eOnlyThisThread, |
| eAllThreads, |
| eOnlyDuringStepping |
| } RunMode; |
| |
| //---------------------------------------------------------------------- |
| // Address Types |
| //---------------------------------------------------------------------- |
| typedef 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; |
| |
| //---------------------------------------------------------------------- |
| // Byte ordering definitions |
| //---------------------------------------------------------------------- |
| typedef enum ByteOrder |
| { |
| eByteOrderInvalid = 0, |
| eByteOrderBig = 1, |
| eByteOrderPDP = 2, |
| eByteOrderLittle = 4 |
| } ByteOrder; |
| |
| //---------------------------------------------------------------------- |
| // Register encoding definitions |
| //---------------------------------------------------------------------- |
| typedef enum Encoding |
| { |
| eEncodingInvalid = 0, |
| eEncodingUint, // unsigned integer |
| eEncodingSint, // signed integer |
| eEncodingIEEE754, // float |
| eEncodingVector // vector registers |
| } Encoding; |
| |
| //---------------------------------------------------------------------- |
| // Display format definitions |
| //---------------------------------------------------------------------- |
| typedef enum Format |
| { |
| eFormatDefault = 0, |
| eFormatInvalid = 0, |
| eFormatBoolean, |
| eFormatBinary, |
| eFormatBytes, |
| eFormatBytesWithASCII, |
| eFormatChar, |
| eFormatCharPrintable, // Only printable characters, space if not printable |
| eFormatComplex, // Floating point complex type |
| eFormatComplexFloat = eFormatComplex, |
| eFormatCString, // NULL terminated C strings |
| eFormatDecimal, |
| eFormatEnum, |
| eFormatHex, |
| eFormatFloat, |
| eFormatOctal, |
| eFormatOSType, // OS character codes encoded into an integer 'PICT' 'text' etc... |
| eFormatUnicode16, |
| eFormatUnicode32, |
| eFormatUnsigned, |
| eFormatPointer, |
| eFormatVectorOfChar, |
| eFormatVectorOfSInt8, |
| eFormatVectorOfUInt8, |
| eFormatVectorOfSInt16, |
| eFormatVectorOfUInt16, |
| eFormatVectorOfSInt32, |
| eFormatVectorOfUInt32, |
| eFormatVectorOfSInt64, |
| eFormatVectorOfUInt64, |
| eFormatVectorOfFloat32, |
| eFormatVectorOfFloat64, |
| eFormatVectorOfUInt128, |
| eFormatComplexInteger // Integer complex type |
| |
| } Format; |
| |
| //---------------------------------------------------------------------- |
| // Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls |
| //---------------------------------------------------------------------- |
| typedef enum DescriptionLevel |
| { |
| eDescriptionLevelBrief = 0, |
| eDescriptionLevelFull, |
| eDescriptionLevelVerbose, |
| kNumDescriptionLevels |
| } DescriptionLevel; |
| |
| //---------------------------------------------------------------------- |
| // Script interpreter types |
| //---------------------------------------------------------------------- |
| typedef enum ScriptLanguage |
| { |
| eScriptLanguageNone, |
| eScriptLanguagePython, |
| eScriptLanguageDefault = eScriptLanguagePython |
| } ScriptLanguage; |
| |
| //---------------------------------------------------------------------- |
| // Register numbering types |
| //---------------------------------------------------------------------- |
| typedef enum RegisterKind |
| { |
| eRegisterKindGCC = 0, // the register numbers seen in eh_frame |
| eRegisterKindDWARF, // the register numbers seen DWARF |
| eRegisterKindGeneric, // insn ptr reg, stack ptr reg, etc not specific to any particular target |
| eRegisterKindGDB, // the register numbers gdb uses (matches stabs numbers?) |
| eRegisterKindLLDB, // lldb's internal register numbers |
| kNumRegisterKinds |
| } RegisterKind; |
| |
| //---------------------------------------------------------------------- |
| // Thread stop reasons |
| //---------------------------------------------------------------------- |
| typedef enum StopReason |
| { |
| eStopReasonInvalid = 0, |
| eStopReasonNone, |
| eStopReasonTrace, |
| eStopReasonBreakpoint, |
| eStopReasonWatchpoint, |
| eStopReasonSignal, |
| eStopReasonException, |
| eStopReasonPlanComplete |
| } StopReason; |
| |
| //---------------------------------------------------------------------- |
| // Votes - Need a tri-state, yes, no, no opinion... |
| //---------------------------------------------------------------------- |
| typedef enum Vote |
| { |
| eVoteNo = -1, |
| eVoteNoOpinion = 0, |
| eVoteYes = 1 |
| } Vote; |
| |
| //---------------------------------------------------------------------- |
| // Symbol types |
| //---------------------------------------------------------------------- |
| typedef enum SymbolType |
| { |
| eSymbolTypeAny = 0, |
| eSymbolTypeInvalid = 0, |
| eSymbolTypeAbsolute, |
| eSymbolTypeExtern, |
| eSymbolTypeCode, |
| eSymbolTypeData, |
| eSymbolTypeTrampoline, |
| eSymbolTypeRuntime, |
| eSymbolTypeException, |
| eSymbolTypeSourceFile, |
| eSymbolTypeHeaderFile, |
| eSymbolTypeObjectFile, |
| eSymbolTypeCommonBlock, |
| eSymbolTypeBlock, |
| eSymbolTypeLocal, |
| eSymbolTypeParam, |
| eSymbolTypeVariable, |
| eSymbolTypeVariableType, |
| eSymbolTypeLineEntry, |
| eSymbolTypeLineHeader, |
| eSymbolTypeScopeBegin, |
| eSymbolTypeScopeEnd, |
| eSymbolTypeAdditional, // When symbols take more than one entry, the extra entries get this type |
| eSymbolTypeCompiler, |
| eSymbolTypeInstrumentation, |
| eSymbolTypeUndefined |
| } SymbolType; |
| |
| |
| //---------------------------------------------------------------------- |
| // Command Return Status Types |
| //---------------------------------------------------------------------- |
| typedef enum ReturnStatus |
| { |
| eReturnStatusInvalid, |
| eReturnStatusSuccessFinishNoResult, |
| eReturnStatusSuccessFinishResult, |
| eReturnStatusSuccessContinuingNoResult, |
| eReturnStatusSuccessContinuingResult, |
| eReturnStatusStarted, |
| eReturnStatusFailed, |
| eReturnStatusQuit |
| } ReturnStatus; |
| |
| |
| //---------------------------------------------------------------------- |
| // Connection Status Types |
| //---------------------------------------------------------------------- |
| typedef enum ConnectionStatus |
| { |
| eConnectionStatusSuccess, // Success |
| eConnectionStatusEndOfFile, // End-of-file encountered |
| eConnectionStatusError, // Check GetError() for details |
| eConnectionStatusTimedOut, // Request timed out |
| eConnectionStatusNoConnection, // No connection |
| eConnectionStatusLostConnection // Lost connection while connected to a valid connection |
| } ConnectionStatus; |
| |
| |
| typedef enum ErrorType |
| { |
| eErrorTypeInvalid, |
| eErrorTypeGeneric, ///< Generic errors that can be any value. |
| eErrorTypeMachKernel, ///< Mach kernel error codes. |
| eErrorTypePOSIX ///< POSIX error codes. |
| } ErrorType; |
| |
| |
| typedef enum ValueType |
| { |
| eValueTypeInvalid = 0, |
| eValueTypeVariableGlobal = 1, // globals variable |
| eValueTypeVariableStatic = 2, // static variable |
| eValueTypeVariableArgument = 3, // function argument variables |
| eValueTypeVariableLocal = 4, // function local variables |
| eValueTypeRegister = 5, // stack frame register value |
| eValueTypeRegisterSet = 6, // A collection of stack frame register values |
| eValueTypeConstResult = 7 // constant result variables |
| } ValueType; |
| |
| //---------------------------------------------------------------------- |
| // Token size/granularities for Input Readers |
| //---------------------------------------------------------------------- |
| |
| typedef enum InputReaderGranularity |
| { |
| eInputReaderGranularityInvalid = 0, |
| eInputReaderGranularityByte, |
| eInputReaderGranularityWord, |
| eInputReaderGranularityLine, |
| eInputReaderGranularityAll |
| } InputReaderGranularity; |
| |
| //------------------------------------------------------------------ |
| /// These mask bits allow a common interface for queries that can |
| /// limit the amount of information that gets parsed to only the |
| /// information that is requested. These bits also can indicate what |
| /// actually did get resolved during query function calls. |
| /// |
| /// Each definition corresponds to a one of the member variables |
| /// in this class, and requests that that item be resolved, or |
| /// indicates that the member did get resolved. |
| //------------------------------------------------------------------ |
| typedef enum SymbolContextItem |
| { |
| eSymbolContextTarget = (1 << 0), ///< Set when \a target is requested from a query, or was located in query results |
| eSymbolContextModule = (1 << 1), ///< Set when \a module is requested from a query, or was located in query results |
| eSymbolContextCompUnit = (1 << 2), ///< Set when \a comp_unit is requested from a query, or was located in query results |
| eSymbolContextFunction = (1 << 3), ///< Set when \a function is requested from a query, or was located in query results |
| eSymbolContextBlock = (1 << 4), ///< Set when the deepest \a block is requested from a query, or was located in query results |
| eSymbolContextLineEntry = (1 << 5), ///< Set when \a line_entry is requested from a query, or was located in query results |
| eSymbolContextSymbol = (1 << 6), ///< Set when \a symbol is requested from a query, or was located in query results |
| eSymbolContextEverything = ((eSymbolContextSymbol << 1) - 1) ///< Indicates to try and lookup everything up during a query. |
| } SymbolContextItem; |
| |
| typedef enum Permissions |
| { |
| ePermissionsWritable = (1 << 0), |
| ePermissionsReadable = (1 << 1), |
| ePermissionsExecutable = (1 << 2) |
| } Permissions; |
| |
| typedef enum SectionType |
| { |
| eSectionTypeInvalid, |
| eSectionTypeCode, |
| eSectionTypeContainer, // The section contains child sections |
| eSectionTypeData, |
| eSectionTypeDataCString, // Inlined C string data |
| eSectionTypeDataCStringPointers, // Pointers to C string data |
| eSectionTypeDataSymbolAddress, // Address of a symbol in the symbol table |
| eSectionTypeData4, |
| eSectionTypeData8, |
| eSectionTypeData16, |
| eSectionTypeDataPointers, |
| eSectionTypeDebug, |
| eSectionTypeZeroFill, |
| eSectionTypeDataObjCMessageRefs, // Pointer to function pointer + selector |
| eSectionTypeDataObjCCFStrings, // Objective C const CFString/NSString objects |
| eSectionTypeDWARFDebugAbbrev, |
| eSectionTypeDWARFDebugAranges, |
| eSectionTypeDWARFDebugFrame, |
| eSectionTypeDWARFDebugInfo, |
| eSectionTypeDWARFDebugLine, |
| eSectionTypeDWARFDebugLoc, |
| eSectionTypeDWARFDebugMacInfo, |
| eSectionTypeDWARFDebugPubNames, |
| eSectionTypeDWARFDebugPubTypes, |
| eSectionTypeDWARFDebugRanges, |
| eSectionTypeDWARFDebugStr, |
| eSectionTypeEHFrame, |
| eSectionTypeOther |
| |
| } SectionType; |
| |
| |
| typedef enum InputReaderAction |
| { |
| eInputReaderActivate, // reader is newly pushed onto the reader stack |
| eInputReaderReactivate, // reader is on top of the stack again after another reader was popped off |
| eInputReaderDeactivate, // another reader was pushed on the stack |
| eInputReaderGotToken, // reader got one of its tokens (granularity) |
| eInputReaderInterrupt, // reader received an interrupt signal (probably from a control-c) |
| eInputReaderEndOfFile, // reader received an EOF char (probably from a control-d) |
| eInputReaderDone // reader was just popped off the stack and is done |
| } InputReaderAction; |
| |
| |
| typedef enum ArchitectureType |
| { |
| eArchTypeInvalid, |
| eArchTypeMachO, |
| eArchTypeELF, |
| kNumArchTypes |
| } ArchitectureType; |
| |
| typedef enum FunctionNameType |
| { |
| eFunctionNameTypeNone = 0u, |
| eFunctionNameTypeAuto = (1u << 1), // Automatically figure out which FunctionNameType |
| // bits to set based on the function name. |
| eFunctionNameTypeFull = (1u << 2), // The function name. |
| // For C this is the same as just the name of the function |
| // For C++ this is the demangled version of the mangled name. |
| // For ObjC this is the full function signature with the + or |
| // - and the square brackets and the class and selector |
| eFunctionNameTypeBase = (1u << 3), // The function name only, no namespaces or arguments and no class |
| // methods or selectors will be searched. |
| eFunctionNameTypeMethod = (1u << 4), // Find function by method name (C++) with no namespace or arguments |
| eFunctionNameTypeSelector = (1u << 5) // Find function by selector name (ObjC) names |
| } FunctionNameType; |
| |
| |
| typedef enum BreakpointEventType |
| { |
| eBreakpointEventTypeInvalidType = (1u << 0), |
| eBreakpointEventTypeAdded = (1u << 1), |
| eBreakpointEventTypeRemoved = (1u << 2), |
| eBreakpointEventTypeLocationsAdded = (1u << 3), |
| eBreakpointEventTypeLocationsRemoved = (1u << 4), |
| eBreakpointEventTypeLocationsResolved = (1u << 5) |
| } BreakpointEventType; |
| |
| |
| //---------------------------------------------------------------------- |
| /// Programming language type. |
| /// |
| /// These enumerations use the same language enumerations as the DWARF |
| /// specification for ease of use and consistency. |
| //---------------------------------------------------------------------- |
| typedef enum LanguageType |
| { |
| eLanguageTypeUnknown = 0x0000, ///< Unknown or invalid language value. |
| eLanguageTypeC89 = 0x0001, ///< ISO C:1989. |
| eLanguageTypeC = 0x0002, ///< Non-standardized C, such as K&R. |
| eLanguageTypeAda83 = 0x0003, ///< ISO Ada:1983. |
| eLanguageTypeC_plus_plus = 0x0004, ///< ISO C++:1998. |
| eLanguageTypeCobol74 = 0x0005, ///< ISO Cobol:1974. |
| eLanguageTypeCobol85 = 0x0006, ///< ISO Cobol:1985. |
| eLanguageTypeFortran77 = 0x0007, ///< ISO Fortran 77. |
| eLanguageTypeFortran90 = 0x0008, ///< ISO Fortran 90. |
| eLanguageTypePascal83 = 0x0009, ///< ISO Pascal:1983. |
| eLanguageTypeModula2 = 0x000a, ///< ISO Modula-2:1996. |
| eLanguageTypeJava = 0x000b, ///< Java. |
| eLanguageTypeC99 = 0x000c, ///< ISO C:1999. |
| eLanguageTypeAda95 = 0x000d, ///< ISO Ada:1995. |
| eLanguageTypeFortran95 = 0x000e, ///< ISO Fortran 95. |
| eLanguageTypePLI = 0x000f, ///< ANSI PL/I:1976. |
| eLanguageTypeObjC = 0x0010, ///< Objective-C. |
| eLanguageTypeObjC_plus_plus = 0x0011, ///< Objective-C++. |
| eLanguageTypeUPC = 0x0012, ///< Unified Parallel C. |
| eLanguageTypeD = 0x0013, ///< D. |
| eLanguageTypePython = 0x0014 ///< Python. |
| } LanguageType; |
| |
| |
| typedef enum AccessType |
| { |
| eAccessNone, |
| eAccessPublic, |
| eAccessPrivate, |
| eAccessProtected, |
| eAccessPackage |
| } AccessType; |
| |
| //---------------------------------------------------------------------- |
| /// Settable state variable types. |
| /// |
| //---------------------------------------------------------------------- |
| |
| typedef enum SettableVariableType |
| { |
| eSetVarTypeInt, |
| eSetVarTypeBoolean, |
| eSetVarTypeString, |
| eSetVarTypeArray, |
| eSetVarTypeDictionary, |
| eSetVarTypeEnum, |
| eSetVarTypeNone |
| } SettableVariableType; |
| |
| typedef enum VarSetOperationType |
| { |
| eVarSetOperationReplace, |
| eVarSetOperationInsertBefore, |
| eVarSetOperationInsertAfter, |
| eVarSetOperationRemove, |
| eVarSetOperationAppend, |
| eVarSetOperationClear, |
| eVarSetOperationAssign, |
| eVarSetOperationInvalid |
| } VarSetOperationType; |
| |
| //---------------------------------------------------------------------- |
| /// Command argument types. |
| /// |
| //---------------------------------------------------------------------- |
| |
| typedef enum CommandArgumentType |
| { |
| eArgTypeAddress = 0, |
| eArgTypeAliasName, |
| eArgTypeAliasOptions, |
| eArgTypeArchitecture, |
| eArgTypeBoolean, |
| eArgTypeBreakpointID, |
| eArgTypeBreakpointIDRange, |
| eArgTypeByteSize, |
| eArgTypeCommandName, |
| eArgTypeCount, |
| eArgTypeEndAddress, |
| eArgTypeExpression, |
| eArgTypeExprFormat, |
| eArgTypeFilename, |
| eArgTypeFormat, |
| eArgTypeFrameIndex, |
| eArgTypeFullName, |
| eArgTypeFunctionName, |
| eArgTypeIndex, |
| eArgTypeLineNum, |
| eArgTypeLogCategory, |
| eArgTypeLogChannel, |
| eArgTypeMethod, |
| eArgTypeName, |
| eArgTypeNewPathPrefix, |
| eArgTypeNumLines, |
| eArgTypeNumberPerLine, |
| eArgTypeOffset, |
| eArgTypeOldPathPrefix, |
| eArgTypeOneLiner, |
| eArgTypePath, |
| eArgTypePid, |
| eArgTypePlugin, |
| eArgTypeProcessName, |
| eArgTypeQueueName, |
| eArgTypeRegisterName, |
| eArgTypeRegularExpression, |
| eArgTypeRunArgs, |
| eArgTypeRunMode, |
| eArgTypeScriptLang, |
| eArgTypeSearchWord, |
| eArgTypeSelector, |
| eArgTypeSettingIndex, |
| eArgTypeSettingKey, |
| eArgTypeSettingPrefix, |
| eArgTypeSettingVariableName, |
| eArgTypeShlibName, |
| eArgTypeSourceFile, |
| eArgTypeSortOrder, |
| eArgTypeStartAddress, |
| eArgTypeSymbol, |
| eArgTypeThreadID, |
| eArgTypeThreadIndex, |
| eArgTypeThreadName, |
| eArgTypeUnixSignal, |
| eArgTypeVarName, |
| eArgTypeValue, |
| eArgTypeWidth, |
| eArgTypeNone, |
| eArgTypeLastArg // Always keep this entry as the last entry in this enumeration!! |
| } CommandArgumentType; |
| |
| typedef 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 |
| { |
| eSortOrderNone, |
| eSortOrderByAddress, |
| eSortOrderByName |
| } SortOrder; |
| |
| |
| //---------------------------------------------------------------------- |
| // Used in conjunction with Host::GetLLDBResource () to find files that |
| // are related to |
| //---------------------------------------------------------------------- |
| typedef enum PathType |
| { |
| ePathTypeLLDBShlibDir, // The directory where the lldb.so (unix) or LLDB mach-o file in LLDB.framework (MacOSX) exists |
| ePathTypeSupportExecutableDir, // Find LLDB support executable directory (debugserver, etc) |
| ePathTypeHeaderDir, // Find LLDB header file directory |
| ePathTypePythonDir, // Find Python modules (PYTHONPATH) directory |
| ePathTypeLLDBSystemPlugins, // System plug-ins directory |
| ePathTypeLLDBUserPlugins // User plug-ins directory |
| } PathType; |
| |
| |
| //---------------------------------------------------------------------- |
| // We can execute ThreadPlans on one thread with various fall-back modes |
| // (try other threads after timeout, etc.) This enum gives the result of |
| // thread plan executions. |
| //---------------------------------------------------------------------- |
| typedef enum ExecutionResults |
| { |
| eExecutionSetupError, |
| eExecutionCompleted, |
| eExecutionDiscarded, |
| eExecutionInterrupted, |
| eExecutionTimedOut |
| } ExecutionResults; |
| |
| typedef enum ObjCRuntimeVersions { |
| eObjC_VersionUnknown = 0, |
| eAppleObjC_V1 = 1, |
| eAppleObjC_V2 = 2 |
| } ObjCRuntimeVersions; |
| |
| |
| //---------------------------------------------------------------------- |
| // 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 { |
| eLazyBoolCalculate = -1, |
| eLazyBoolNo = 0, |
| eLazyBoolYes = 1 |
| } LazyBool; |
| |
| //------------------------------------------------------------------ |
| /// Execution Level |
| //------------------------------------------------------------------ |
| typedef enum ExecutionLevel |
| { |
| eExecutionLevelAuto, // Automatically detect how to run an executable |
| eExecutionLevelKernel, // Execute a program as a kernel executable |
| eExecutionLevelUser // Execute a program as a user space executable |
| } ExecutionLevel; |
| |
| |
| //------------------------------------------------------------------ |
| /// Execution mode |
| //------------------------------------------------------------------ |
| typedef enum ExecutionMode |
| { |
| // Automatically detect the execution mode |
| eExecutionModeAuto, |
| |
| // Execute with no shared libraries, everything is where the executable |
| // files say they are (file addresses == load addresses) |
| eExecutionModeStatic, |
| |
| // Execute with shared libraries using a dynamic loader plug-in to |
| // detect when shared libraries are loaded/unloaded. |
| eExecutionModeDynamic |
| |
| } ExecutionMode; |
| |
| //------------------------------------------------------------------ |
| /// Execution OS |
| //------------------------------------------------------------------ |
| typedef enum ExecutionOSType |
| { |
| // Automatically detect the execution operating system |
| eExecutionOSTypeAuto, |
| |
| // There is no operating system (no processes or threads). |
| eExecutionOSTypeNone, |
| |
| // There is an OS, but when we execution stops, the entire OS is halted |
| // (common when debugging in eExecutionLevelKernel modes). Processes and |
| // threads can be queried, selected and switched between using memory |
| // reads/writes using a ProcessHelper plug-in (which has yet to be |
| // designed). |
| eExecutionOSTypeHalted, |
| |
| // There is live OS with debug services that we can talk to for process, |
| // thread, and other OS queries. |
| eExecutionOSTypeLive |
| |
| } ExecutionOSType; |
| |
| |
| } // namespace lldb |
| |
| |
| #endif // LLDB_enumerations_h_ |
