gdb/gdbserver/linux-low.h

   1 /* Internal interfaces for the GNU/Linux specific target code for gdbserver.
   2    Copyright (C) 2002-2013 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "gdb_thread_db.h"
  20 #include <signal.h>
  21
  22 #include "gdbthread.h"
  23 #include "gdb_proc_service.h"
  24
  25 #define PTRACE_ARG3_TYPE void *
  26 #define PTRACE_ARG4_TYPE void *
  27 #define PTRACE_XFER_TYPE long
  28
  29 #ifdef HAVE_LINUX_REGSETS
  30 typedef void (*regset_fill_func) (struct regcache *, void *);
  31 typedef void (*regset_store_func) (struct regcache *, const void *);
  32 enum regset_type {
  33   GENERAL_REGS,
  34   FP_REGS,
  35   EXTENDED_REGS,
  36 };
  37
  38 struct regset_info
  39 {
  40   int get_request, set_request;
  41   /* If NT_TYPE isn't 0, it will be passed to ptrace as the 3rd
  42      argument and the 4th argument should be "const struct iovec *".  */
  43   int nt_type;
  44   int size;
  45   enum regset_type type;
  46   regset_fill_func fill_function;
  47   regset_store_func store_function;
  48 };
  49
  50 /* Aggregation of all the supported regsets of a given
  51    architecture/mode.  */
  52
  53 struct regsets_info
  54 {
  55   /* The regsets array.  */
  56   struct regset_info *regsets;
  57
  58   /* The number of regsets in the REGSETS array.  */
  59   int num_regsets;
  60
  61   /* If we get EIO on a regset, do not try it again.  Note the set of
  62      supported regsets may depend on processor mode on biarch
  63      machines.  */
  64   char *disabled_regsets;
  65 };
  66
  67 #endif
  68
  69 /* Mapping between the general-purpose registers in `struct user'
  70    format and GDB's register array layout.  */
  71
  72 struct usrregs_info
  73 {
  74   /* The number of registers accessible.  */
  75   int num_regs;
  76
  77   /* The registers map.  */
  78   int *regmap;
  79 };
  80
  81 /* All info needed to access an architecture/mode's registers.  */
  82
  83 struct regs_info
  84 {
  85   /* Regset support bitmap: 1 for registers that are transferred as a part
  86      of a regset, 0 for ones that need to be handled individually.  This
  87      can be NULL if all registers are transferred with regsets or regsets
  88      are not supported.  */
  89   unsigned char *regset_bitmap;
  90
  91   /* Info used when accessing registers with PTRACE_PEEKUSER /
  92      PTRACE_POKEUSER.  This can be NULL if all registers are
  93      transferred with regsets  .*/
  94   struct usrregs_info *usrregs;
  95
  96 #ifdef HAVE_LINUX_REGSETS
  97   /* Info used when accessing registers with regsets.  */
  98   struct regsets_info *regsets_info;
  99 #endif
 100 };
 101
 102 struct process_info_private
 103 {
 104   /* Arch-specific additions.  */
 105   struct arch_process_info *arch_private;
 106
 107   /* libthread_db-specific additions.  Not NULL if this process has loaded
 108      thread_db, and it is active.  */
 109   struct thread_db *thread_db;
 110
 111   /* &_r_debug.  0 if not yet determined.  -1 if no PT_DYNAMIC in Phdrs.  */
 112   CORE_ADDR r_debug;
 113
 114   /* This flag is true iff we've just created or attached to the first
 115      LWP of this process but it has not stopped yet.  As soon as it
 116      does, we need to call the low target's arch_setup callback.  */
 117   int new_inferior;
 118 };
 119
 120 struct lwp_info;
 121
 122 struct linux_target_ops
 123 {
 124   /* Architecture-specific setup.  */
 125   void (*arch_setup) (void);
 126
 127   const struct regs_info *(*regs_info) (void);
 128   int (*cannot_fetch_register) (int);
 129
 130   /* Returns 0 if we can store the register, 1 if we can not
 131      store the register, and 2 if failure to store the register
 132      is acceptable.  */
 133   int (*cannot_store_register) (int);
 134
 135   /* Hook to fetch a register in some non-standard way.  Used for
 136      example by backends that have read-only registers with hardcoded
 137      values (e.g., IA64's gr0/fr0/fr1).  Returns true if register
 138      REGNO was supplied, false if not, and we should fallback to the
 139      standard ptrace methods.  */
 140   int (*fetch_register) (struct regcache *regcache, int regno);
 141
 142   CORE_ADDR (*get_pc) (struct regcache *regcache);
 143   void (*set_pc) (struct regcache *regcache, CORE_ADDR newpc);
 144   const unsigned char *breakpoint;
 145   int breakpoint_len;
 146   CORE_ADDR (*breakpoint_reinsert_addr) (void);
 147
 148   int decr_pc_after_break;
 149   int (*breakpoint_at) (CORE_ADDR pc);
 150
 151   /* Breakpoint and watchpoint related functions.  See target.h for
 152      comments.  */
 153   int (*insert_point) (char type, CORE_ADDR addr, int len);
 154   int (*remove_point) (char type, CORE_ADDR addr, int len);
 155   int (*stopped_by_watchpoint) (void);
 156   CORE_ADDR (*stopped_data_address) (void);
 157
 158   /* Hooks to reformat register data for PEEKUSR/POKEUSR (in particular
 159      for registers smaller than an xfer unit).  */
 160   void (*collect_ptrace_register) (struct regcache *regcache,
 161                                    int regno, char *buf);
 162   void (*supply_ptrace_register) (struct regcache *regcache,
 163                                   int regno, const char *buf);
 164
 165   /* Hook to convert from target format to ptrace format and back.
 166      Returns true if any conversion was done; false otherwise.
 167      If DIRECTION is 1, then copy from INF to NATIVE.
 168      If DIRECTION is 0, copy from NATIVE to INF.  */
 169   int (*siginfo_fixup) (siginfo_t *native, void *inf, int direction);
 170
 171   /* Hook to call when a new process is created or attached to.
 172      If extra per-process architecture-specific data is needed,
 173      allocate it here.  */
 174   struct arch_process_info * (*new_process) (void);
 175
 176   /* Hook to call when a new thread is detected.
 177      If extra per-thread architecture-specific data is needed,
 178      allocate it here.  */
 179   struct arch_lwp_info * (*new_thread) (void);
 180
 181   /* Hook to call prior to resuming a thread.  */
 182   void (*prepare_to_resume) (struct lwp_info *);
 183
 184   /* Hook to support target specific qSupported.  */
 185   void (*process_qsupported) (const char *);
 186
 187   /* Returns true if the low target supports tracepoints.  */
 188   int (*supports_tracepoints) (void);
 189
 190   /* Fill ADDRP with the thread area address of LWPID.  Returns 0 on
 191      success, -1 on failure.  */
 192   int (*get_thread_area) (int lwpid, CORE_ADDR *addrp);
 193
 194   /* Install a fast tracepoint jump pad.  See target.h for
 195      comments.  */
 196   int (*install_fast_tracepoint_jump_pad) (CORE_ADDR tpoint, CORE_ADDR tpaddr,
 197                                            CORE_ADDR collector,
 198                                            CORE_ADDR lockaddr,
 199                                            ULONGEST orig_size,
 200                                            CORE_ADDR *jump_entry,
 201                                            CORE_ADDR *trampoline,
 202                                            ULONGEST *trampoline_size,
 203                                            unsigned char *jjump_pad_insn,
 204                                            ULONGEST *jjump_pad_insn_size,
 205                                            CORE_ADDR *adjusted_insn_addr,
 206                                            CORE_ADDR *adjusted_insn_addr_end,
 207                                            char *err);
 208
 209   /* Return the bytecode operations vector for the current inferior.
 210      Returns NULL if bytecode compilation is not supported.  */
 211   struct emit_ops *(*emit_ops) (void);
 212
 213   /* Return the minimum length of an instruction that can be safely overwritten
 214      for use as a fast tracepoint.  */
 215   int (*get_min_fast_tracepoint_insn_len) (void);
 216
 217   /* Returns true if the low target supports range stepping.  */
 218   int (*supports_range_stepping) (void);
 219 };
 220
 221 extern struct linux_target_ops the_low_target;
 222
 223 #define ptid_of(proc) ((proc)->head.id)
 224 #define pid_of(proc) ptid_get_pid ((proc)->head.id)
 225 #define lwpid_of(proc) ptid_get_lwp ((proc)->head.id)
 226
 227 #define get_lwp(inf) ((struct lwp_info *)(inf))
 228 #define get_thread_lwp(thr) (get_lwp (inferior_target_data (thr)))
 229 #define get_lwp_thread(proc) ((struct thread_info *)                    \
 230                               find_inferior_id (&all_threads,           \
 231                                                 get_lwp (proc)->head.id))
 232
 233 struct lwp_info
 234 {
 235   struct inferior_list_entry head;
 236
 237   /* If this flag is set, the next SIGSTOP will be ignored (the
 238      process will be immediately resumed).  This means that either we
 239      sent the SIGSTOP to it ourselves and got some other pending event
 240      (so the SIGSTOP is still pending), or that we stopped the
 241      inferior implicitly via PTRACE_ATTACH and have not waited for it
 242      yet.  */
 243   int stop_expected;
 244
 245   /* When this is true, we shall not try to resume this thread, even
 246      if last_resume_kind isn't resume_stop.  */
 247   int suspended;
 248
 249   /* If this flag is set, the lwp is known to be stopped right now (stop
 250      event already received in a wait()).  */
 251   int stopped;
 252
 253   /* If this flag is set, the lwp is known to be dead already (exit
 254      event already received in a wait(), and is cached in
 255      status_pending).  */
 256   int dead;
 257
 258   /* When stopped is set, the last wait status recorded for this lwp.  */
 259   int last_status;
 260
 261   /* When stopped is set, this is where the lwp stopped, with
 262      decr_pc_after_break already accounted for.  */
 263   CORE_ADDR stop_pc;
 264
 265   /* If this flag is set, STATUS_PENDING is a waitstatus that has not yet
 266      been reported.  */
 267   int status_pending_p;
 268   int status_pending;
 269
 270   /* STOPPED_BY_WATCHPOINT is non-zero if this LWP stopped with a data
 271      watchpoint trap.  */
 272   int stopped_by_watchpoint;
 273
 274   /* On architectures where it is possible to know the data address of
 275      a triggered watchpoint, STOPPED_DATA_ADDRESS is non-zero, and
 276      contains such data address.  Only valid if STOPPED_BY_WATCHPOINT
 277      is true.  */
 278   CORE_ADDR stopped_data_address;
 279
 280   /* If this is non-zero, it is a breakpoint to be reinserted at our next
 281      stop (SIGTRAP stops only).  */
 282   CORE_ADDR bp_reinsert;
 283
 284   /* If this flag is set, the last continue operation at the ptrace
 285      level on this process was a single-step.  */
 286   int stepping;
 287
 288   /* Range to single step within.  This is a copy of the step range
 289      passed along the last resume request.  See 'struct
 290      thread_resume'.  */
 291   CORE_ADDR step_range_start;   /* Inclusive */
 292   CORE_ADDR step_range_end;     /* Exclusive */
 293
 294   /* If this flag is set, we need to set the event request flags the
 295      next time we see this LWP stop.  */
 296   int must_set_ptrace_flags;
 297
 298   /* If this is non-zero, it points to a chain of signals which need to
 299      be delivered to this process.  */
 300   struct pending_signals *pending_signals;
 301
 302   /* A link used when resuming.  It is initialized from the resume request,
 303      and then processed and cleared in linux_resume_one_lwp.  */
 304   struct thread_resume *resume;
 305
 306   /* True if it is known that this lwp is presently collecting a fast
 307      tracepoint (it is in the jump pad or in some code that will
 308      return to the jump pad.  Normally, we won't care about this, but
 309      we will if a signal arrives to this lwp while it is
 310      collecting.  */
 311   int collecting_fast_tracepoint;
 312
 313   /* If this is non-zero, it points to a chain of signals which need
 314      to be reported to GDB.  These were deferred because the thread
 315      was doing a fast tracepoint collect when they arrived.  */
 316   struct pending_signals *pending_signals_to_report;
 317
 318   /* When collecting_fast_tracepoint is first found to be 1, we insert
 319      a exit-jump-pad-quickly breakpoint.  This is it.  */
 320   struct breakpoint *exit_jump_pad_bkpt;
 321
 322   /* True if the LWP was seen stop at an internal breakpoint and needs
 323      stepping over later when it is resumed.  */
 324   int need_step_over;
 325
 326 #ifdef USE_THREAD_DB
 327   int thread_known;
 328   /* The thread handle, used for e.g. TLS access.  Only valid if
 329      THREAD_KNOWN is set.  */
 330   td_thrhandle_t th;
 331 #endif
 332
 333   /* Arch-specific additions.  */
 334   struct arch_lwp_info *arch_private;
 335 };
 336
 337 extern struct inferior_list all_lwps;
 338
 339 int linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine);
 340
 341 void linux_attach_lwp (unsigned long pid);
 342 struct lwp_info *find_lwp_pid (ptid_t ptid);
 343 void linux_stop_lwp (struct lwp_info *lwp);
 344
 345 #ifdef HAVE_LINUX_REGSETS
 346 void initialize_regsets_info (struct regsets_info *regsets_info);
 347 #endif
 348
 349 void initialize_low_arch (void);
 350
 351 /* From thread-db.c  */
 352 int thread_db_init (int use_events);
 353 void thread_db_detach (struct process_info *);
 354 void thread_db_mourn (struct process_info *);
 355 int thread_db_handle_monitor_command (char *);
 356 int thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
 357                                CORE_ADDR load_module, CORE_ADDR *address);
 358 int thread_db_look_up_one_symbol (const char *name, CORE_ADDR *addrp);