tools/debugserver/source/DNBDefs.h

   1 //===-- DNBDefs.h -----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  Created by Greg Clayton on 6/26/07.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef __DNBDefs_h__
  15 #define __DNBDefs_h__
  16
  17 #include <signal.h>
  18 #include <stdint.h>
  19 #include <stdio.h>
  20 #include <sys/syslimits.h>
  21 #include <unistd.h>
  22
  23 //----------------------------------------------------------------------
  24 // Define nub_addr_t and the invalid address value from the architecture
  25 //----------------------------------------------------------------------
  26 #if defined(__x86_64__) || defined(__ppc64__) || defined(__arm64__) ||         \
  27     defined(__aarch64__)
  28
  29 //----------------------------------------------------------------------
  30 // 64 bit address architectures
  31 //----------------------------------------------------------------------
  32 typedef uint64_t nub_addr_t;
  33 #define INVALID_NUB_ADDRESS ((nub_addr_t)~0ull)
  34
  35 #elif defined(__i386__) || defined(__powerpc__) || defined(__ppc__) ||         \
  36     defined(__arm__)
  37
  38 //----------------------------------------------------------------------
  39 // 32 bit address architectures
  40 //----------------------------------------------------------------------
  41
  42 typedef uint32_t nub_addr_t;
  43 #define INVALID_NUB_ADDRESS ((nub_addr_t)~0ul)
  44
  45 #else
  46
  47 //----------------------------------------------------------------------
  48 // Default to 64 bit address for unrecognized architectures.
  49 //----------------------------------------------------------------------
  50
  51 #warning undefined architecture, defaulting to 8 byte addresses
  52 typedef uint64_t nub_addr_t;
  53 #define INVALID_NUB_ADDRESS ((nub_addr_t)~0ull)
  54
  55 #endif
  56
  57 typedef size_t nub_size_t;
  58 typedef ssize_t nub_ssize_t;
  59 typedef uint32_t nub_index_t;
  60 typedef pid_t nub_process_t;
  61 typedef uint64_t nub_thread_t;
  62 typedef uint32_t nub_event_t;
  63 typedef uint32_t nub_bool_t;
  64
  65 #define INVALID_NUB_PROCESS ((nub_process_t)0)
  66 #define INVALID_NUB_THREAD ((nub_thread_t)0)
  67 #define INVALID_NUB_WATCH_ID ((nub_watch_t)0)
  68 #define INVALID_NUB_HW_INDEX UINT32_MAX
  69 #define INVALID_NUB_REGNUM UINT32_MAX
  70 #define NUB_GENERIC_ERROR UINT32_MAX
  71
  72 // Watchpoint types
  73 #define WATCH_TYPE_READ (1u << 0)
  74 #define WATCH_TYPE_WRITE (1u << 1)
  75
  76 typedef enum {
  77   eStateInvalid = 0,
  78   eStateUnloaded,
  79   eStateAttaching,
  80   eStateLaunching,
  81   eStateStopped,
  82   eStateRunning,
  83   eStateStepping,
  84   eStateCrashed,
  85   eStateDetached,
  86   eStateExited,
  87   eStateSuspended
  88 } nub_state_t;
  89
  90 typedef enum {
  91   eLaunchFlavorDefault = 0,
  92   eLaunchFlavorPosixSpawn = 1,
  93   eLaunchFlavorForkExec = 2,
  94 #ifdef WITH_SPRINGBOARD
  95   eLaunchFlavorSpringBoard = 3,
  96 #endif
  97 #ifdef WITH_BKS
  98   eLaunchFlavorBKS = 4,
  99 #endif
 100 #ifdef WITH_FBS
 101   eLaunchFlavorFBS = 5
 102 #endif
 103 } nub_launch_flavor_t;
 104
 105 #define NUB_STATE_IS_RUNNING(s)                                                \
 106   ((s) == eStateAttaching || (s) == eStateLaunching || (s) == eStateRunning || \
 107    (s) == eStateStepping || (s) == eStateDetached)
 108
 109 #define NUB_STATE_IS_STOPPED(s)                                                \
 110   ((s) == eStateUnloaded || (s) == eStateStopped || (s) == eStateCrashed ||    \
 111    (s) == eStateExited)
 112
 113 enum {
 114   eEventProcessRunningStateChanged =
 115       1 << 0, // The process has changed state to running
 116   eEventProcessStoppedStateChanged =
 117       1 << 1, // The process has changed state to stopped
 118   eEventSharedLibsStateChange =
 119       1 << 2, // Shared libraries loaded/unloaded state has changed
 120   eEventStdioAvailable = 1 << 3, // Something is available on stdout/stderr
 121   eEventProfileDataAvailable = 1 << 4, // Profile data ready for retrieval
 122   kAllEventsMask = eEventProcessRunningStateChanged |
 123                    eEventProcessStoppedStateChanged |
 124                    eEventSharedLibsStateChange | eEventStdioAvailable |
 125                    eEventProfileDataAvailable
 126 };
 127
 128 #define LOG_VERBOSE (1u << 0)
 129 #define LOG_PROCESS (1u << 1)
 130 #define LOG_THREAD (1u << 2)
 131 #define LOG_EXCEPTIONS (1u << 3)
 132 #define LOG_SHLIB (1u << 4)
 133 #define LOG_MEMORY (1u << 5)             // Log memory reads/writes calls
 134 #define LOG_MEMORY_DATA_SHORT (1u << 6)  // Log short memory reads/writes bytes
 135 #define LOG_MEMORY_DATA_LONG (1u << 7)   // Log all memory reads/writes bytes
 136 #define LOG_MEMORY_PROTECTIONS (1u << 8) // Log memory protection changes
 137 #define LOG_BREAKPOINTS (1u << 9)
 138 #define LOG_EVENTS (1u << 10)
 139 #define LOG_WATCHPOINTS (1u << 11)
 140 #define LOG_STEP (1u << 12)
 141 #define LOG_TASK (1u << 13)
 142 #define LOG_DARWIN_LOG (1u << 14)
 143 #define LOG_LO_USER (1u << 16)
 144 #define LOG_HI_USER (1u << 31)
 145 #define LOG_ALL 0xFFFFFFFFu
 146 #define LOG_DEFAULT                                                            \
 147   ((LOG_PROCESS) | (LOG_TASK) | (LOG_THREAD) | (LOG_EXCEPTIONS) |              \
 148    (LOG_SHLIB) | (LOG_MEMORY) | (LOG_BREAKPOINTS) | (LOG_WATCHPOINTS) |        \
 149    (LOG_STEP))
 150
 151 #define REGISTER_SET_ALL 0
 152 // Generic Register set to be defined by each architecture for access to common
 153 // register values.
 154 #define REGISTER_SET_GENERIC ((uint32_t)0xFFFFFFFFu)
 155 #define GENERIC_REGNUM_PC 0    // Program Counter
 156 #define GENERIC_REGNUM_SP 1    // Stack Pointer
 157 #define GENERIC_REGNUM_FP 2    // Frame Pointer
 158 #define GENERIC_REGNUM_RA 3    // Return Address
 159 #define GENERIC_REGNUM_FLAGS 4 // Processor flags register
 160 #define GENERIC_REGNUM_ARG1                                                    \
 161   5 // The register that would contain pointer size or less argument 1 (if any)
 162 #define GENERIC_REGNUM_ARG2                                                    \
 163   6 // The register that would contain pointer size or less argument 2 (if any)
 164 #define GENERIC_REGNUM_ARG3                                                    \
 165   7 // The register that would contain pointer size or less argument 3 (if any)
 166 #define GENERIC_REGNUM_ARG4                                                    \
 167   8 // The register that would contain pointer size or less argument 4 (if any)
 168 #define GENERIC_REGNUM_ARG5                                                    \
 169   9 // The register that would contain pointer size or less argument 5 (if any)
 170 #define GENERIC_REGNUM_ARG6                                                    \
 171   10 // The register that would contain pointer size or less argument 6 (if any)
 172 #define GENERIC_REGNUM_ARG7                                                    \
 173   11 // The register that would contain pointer size or less argument 7 (if any)
 174 #define GENERIC_REGNUM_ARG8                                                    \
 175   12 // The register that would contain pointer size or less argument 8 (if any)
 176
 177 enum DNBRegisterType {
 178   InvalidRegType = 0,
 179   Uint,    // unsigned integer
 180   Sint,    // signed integer
 181   IEEE754, // float
 182   Vector   // vector registers
 183 };
 184
 185 enum DNBRegisterFormat {
 186   InvalidRegFormat = 0,
 187   Binary,
 188   Decimal,
 189   Hex,
 190   Float,
 191   VectorOfSInt8,
 192   VectorOfUInt8,
 193   VectorOfSInt16,
 194   VectorOfUInt16,
 195   VectorOfSInt32,
 196   VectorOfUInt32,
 197   VectorOfFloat32,
 198   VectorOfUInt128
 199 };
 200
 201 struct DNBRegisterInfo {
 202   uint32_t set;     // Register set
 203   uint32_t reg;     // Register number
 204   const char *name; // Name of this register
 205   const char *alt;  // Alternate name
 206   uint16_t type;    // Type of the register bits (DNBRegisterType)
 207   uint16_t format;  // Default format for display (DNBRegisterFormat),
 208   uint32_t size;    // Size in bytes of the register
 209   uint32_t offset;  // Offset from the beginning of the register context
 210   uint32_t
 211       reg_ehframe;    // eh_frame register number (INVALID_NUB_REGNUM when none)
 212   uint32_t reg_dwarf; // DWARF register number (INVALID_NUB_REGNUM when none)
 213   uint32_t
 214       reg_generic; // Generic register number (INVALID_NUB_REGNUM when none)
 215   uint32_t reg_debugserver; // The debugserver register number we'll use over
 216                             // gdb-remote protocol (INVALID_NUB_REGNUM when
 217                             // none)
 218   const char **value_regs;  // If this register is a part of other registers,
 219                             // list the register names terminated by NULL
 220   const char **update_regs; // If modifying this register will invalidate other
 221                             // registers, list the register names terminated by
 222                             // NULL
 223 };
 224
 225 struct DNBRegisterSetInfo {
 226   const char *name;                        // Name of this register set
 227   const struct DNBRegisterInfo *registers; // An array of register descriptions
 228   nub_size_t num_registers; // The number of registers in REGISTERS array above
 229 };
 230
 231 struct DNBThreadResumeAction {
 232   nub_thread_t tid;  // The thread ID that this action applies to,
 233                      // INVALID_NUB_THREAD for the default thread action
 234   nub_state_t state; // Valid values are eStateStopped/eStateSuspended,
 235                      // eStateRunning, and eStateStepping.
 236   int signal;        // When resuming this thread, resume it with this signal
 237   nub_addr_t addr; // If not INVALID_NUB_ADDRESS, then set the PC for the thread
 238                    // to ADDR before resuming/stepping
 239 };
 240
 241 enum DNBThreadStopType {
 242   eStopTypeInvalid = 0,
 243   eStopTypeSignal,
 244   eStopTypeException,
 245   eStopTypeExec
 246 };
 247
 248 enum DNBMemoryPermissions {
 249   eMemoryPermissionsWritable = (1 << 0),
 250   eMemoryPermissionsReadable = (1 << 1),
 251   eMemoryPermissionsExecutable = (1 << 2)
 252 };
 253
 254 #define DNB_THREAD_STOP_INFO_MAX_DESC_LENGTH 256
 255 #define DNB_THREAD_STOP_INFO_MAX_EXC_DATA 8
 256
 257 //----------------------------------------------------------------------
 258 // DNBThreadStopInfo
 259 //
 260 // Describes the reason a thread stopped.
 261 //----------------------------------------------------------------------
 262 struct DNBThreadStopInfo {
 263   DNBThreadStopType reason;
 264   char description[DNB_THREAD_STOP_INFO_MAX_DESC_LENGTH];
 265   union {
 266     // eStopTypeSignal
 267     struct {
 268       uint32_t signo;
 269     } signal;
 270
 271     // eStopTypeException
 272     struct {
 273       uint32_t type;
 274       nub_size_t data_count;
 275       nub_addr_t data[DNB_THREAD_STOP_INFO_MAX_EXC_DATA];
 276     } exception;
 277   } details;
 278 };
 279
 280 struct DNBRegisterValue {
 281   struct DNBRegisterInfo info; // Register information for this register
 282   union {
 283     int8_t sint8;
 284     int16_t sint16;
 285     int32_t sint32;
 286     int64_t sint64;
 287     uint8_t uint8;
 288     uint16_t uint16;
 289     uint32_t uint32;
 290     uint64_t uint64;
 291     float float32;
 292     double float64;
 293     int8_t v_sint8[32];
 294     int16_t v_sint16[16];
 295     int32_t v_sint32[8];
 296     int64_t v_sint64[4];
 297     uint8_t v_uint8[32];
 298     uint16_t v_uint16[16];
 299     uint32_t v_uint32[8];
 300     uint64_t v_uint64[4];
 301     float v_float32[8];
 302     double v_float64[4];
 303     void *pointer;
 304     char *c_str;
 305   } value;
 306 };
 307
 308 enum DNBSharedLibraryState { eShlibStateUnloaded = 0, eShlibStateLoaded = 1 };
 309
 310 #ifndef DNB_MAX_SEGMENT_NAME_LENGTH
 311 #define DNB_MAX_SEGMENT_NAME_LENGTH 32
 312 #endif
 313
 314 struct DNBSegment {
 315   char name[DNB_MAX_SEGMENT_NAME_LENGTH];
 316   nub_addr_t addr;
 317   nub_addr_t size;
 318 };
 319
 320 struct DNBExecutableImageInfo {
 321   char name[PATH_MAX]; // Name of the executable image (usually a full path)
 322   uint32_t
 323       state; // State of the executable image (see enum DNBSharedLibraryState)
 324   nub_addr_t header_addr; // Executable header address
 325   uuid_t uuid;            // Unique identifier for matching with symbols
 326   uint32_t
 327       num_segments; // Number of contiguous memory segments to in SEGMENTS array
 328   DNBSegment *segments; // Array of contiguous memory segments in executable
 329 };
 330
 331 struct DNBRegionInfo {
 332   nub_addr_t addr;
 333   nub_addr_t size;
 334   uint32_t permissions;
 335 };
 336
 337 enum DNBProfileDataScanType {
 338   eProfileHostCPU = (1 << 0),
 339   eProfileCPU = (1 << 1),
 340
 341   eProfileThreadsCPU =
 342       (1 << 2), // By default excludes eProfileThreadName and eProfileQueueName.
 343   eProfileThreadName =
 344       (1 << 3), // Assume eProfileThreadsCPU, get thread name as well.
 345   eProfileQueueName =
 346       (1 << 4), // Assume eProfileThreadsCPU, get queue name as well.
 347
 348   eProfileHostMemory = (1 << 5),
 349
 350   eProfileMemory = (1 << 6), // By default, excludes eProfileMemoryDirtyPage.
 351   eProfileMemoryDirtyPage =
 352       (1 << 7), // Assume eProfileMemory, get Dirty Page size as well.
 353   eProfileMemoryAnonymous =
 354       (1 << 8), // Assume eProfileMemory, get Anonymous memory as well.
 355
 356   eProfileEnergy = (1 << 9),
 357
 358   eProfileAll = 0xffffffff
 359 };
 360
 361 typedef nub_addr_t (*DNBCallbackNameToAddress)(nub_process_t pid,
 362                                                const char *name,
 363                                                const char *shlib_regex,
 364                                                void *baton);
 365 typedef nub_size_t (*DNBCallbackCopyExecutableImageInfos)(
 366     nub_process_t pid, struct DNBExecutableImageInfo **image_infos,
 367     nub_bool_t only_changed, void *baton);
 368 typedef void (*DNBCallbackLog)(void *baton, uint32_t flags, const char *format,
 369                                va_list args);
 370
 371 #define UNUSED_IF_ASSERT_DISABLED(x) ((void)(x))
 372
 373 #endif // #ifndef __DNBDefs_h__