gdb/gdbserver/server.h

   1 /* Common definitions for remote server for GDB.
   2    Copyright (C) 1993, 1995, 1997-2000, 2002-2012 Free Software
   3    Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef SERVER_H
  21 #define SERVER_H
  22
  23 #include "config.h"
  24
  25 #ifdef __MINGW32CE__
  26 #include "wincecompat.h"
  27 #endif
  28
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #ifdef HAVE_ERRNO_H
  33 #include <errno.h>
  34 #endif
  35 #include <setjmp.h>
  36
  37 #ifdef HAVE_STRING_H
  38 #include <string.h>
  39 #endif
  40
  41 #ifdef HAVE_ALLOCA_H
  42 #include <alloca.h>
  43 #endif
  44 /* On some systems such as MinGW, alloca is declared in malloc.h
  45    (there is no alloca.h).  */
  46 #if HAVE_MALLOC_H
  47 #include <malloc.h>
  48 #endif
  49
  50 #if !HAVE_DECL_STRERROR
  51 #ifndef strerror
  52 extern char *strerror (int);    /* X3.159-1989  4.11.6.2 */
  53 #endif
  54 #endif
  55
  56 #if !HAVE_DECL_PERROR
  57 #ifndef perror
  58 extern void perror (const char *);
  59 #endif
  60 #endif
  61
  62 #if !HAVE_DECL_MEMMEM
  63 extern void *memmem (const void *, size_t , const void *, size_t);
  64 #endif
  65
  66 #if !HAVE_DECL_VASPRINTF
  67 extern int vasprintf(char **strp, const char *fmt, va_list ap);
  68 #endif
  69 #if !HAVE_DECL_VSNPRINTF
  70 int vsnprintf(char *str, size_t size, const char *format, va_list ap);
  71 #endif
  72
  73 #ifndef ATTR_NORETURN
  74 #if defined(__GNUC__) && (__GNUC__ > 2 \
  75                           || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7))
  76 #define ATTR_NORETURN __attribute__ ((noreturn))
  77 #else
  78 #define ATTR_NORETURN           /* nothing */
  79 #endif
  80 #endif
  81
  82 #ifndef ATTR_FORMAT
  83 #if defined(__GNUC__) && (__GNUC__ > 2 \
  84                           || (__GNUC__ == 2 && __GNUC_MINOR__ >= 4))
  85 #define ATTR_FORMAT(type, x, y) __attribute__ ((format(type, x, y)))
  86 #else
  87 #define ATTR_FORMAT(type, x, y) /* nothing */
  88 #endif
  89 #endif
  90
  91 #ifndef ATTR_MALLOC
  92 #if defined(__GNUC__) && (__GNUC__ >= 3)
  93 #define ATTR_MALLOC __attribute__ ((__malloc__))
  94 #else
  95 #define ATTR_MALLOC             /* nothing */
  96 #endif
  97 #endif
  98
  99 /* Define underscore macro, if not available, to be able to use it inside
 100    code shared with gdb in common directory.  */
 101 #ifndef _
 102 #define _(String) (String)
 103 #endif
 104
 105 #ifdef IN_PROCESS_AGENT
 106 #  define PROG "ipa"
 107 #else
 108 #  define PROG "gdbserver"
 109 #endif
 110
 111 /* A type used for binary buffers.  */
 112 typedef unsigned char gdb_byte;
 113
 114 #include "ptid.h"
 115 #include "buffer.h"
 116 #include "xml-utils.h"
 117 #include "gdb_locale.h"
 118
 119 /* FIXME: This should probably be autoconf'd for.  It's an integer type at
 120    least the size of a (void *).  */
 121 typedef long long CORE_ADDR;
 122
 123 typedef long long LONGEST;
 124 typedef unsigned long long ULONGEST;
 125
 126 /* Generic information for tracking a list of ``inferiors'' - threads,
 127    processes, etc.  */
 128 struct inferior_list
 129 {
 130   struct inferior_list_entry *head;
 131   struct inferior_list_entry *tail;
 132 };
 133 struct inferior_list_entry
 134 {
 135   ptid_t id;
 136   struct inferior_list_entry *next;
 137 };
 138
 139 struct thread_info;
 140 struct process_info;
 141 struct regcache;
 142
 143 #include "regcache.h"
 144 #include "gdb/signals.h"
 145 #include "gdb_signals.h"
 146 #include "target.h"
 147 #include "mem-break.h"
 148
 149 struct thread_info
 150 {
 151   struct inferior_list_entry entry;
 152   void *target_data;
 153   void *regcache_data;
 154
 155   /* The last resume GDB requested on this thread.  */
 156   enum resume_kind last_resume_kind;
 157
 158   /* The last wait status reported for this thread.  */
 159   struct target_waitstatus last_status;
 160
 161   /* Given `while-stepping', a thread may be collecting data for more
 162      than one tracepoint simultaneously.  E.g.:
 163
 164     ff0001  INSN1 <-- TP1, while-stepping 10 collect $regs
 165     ff0002  INSN2
 166     ff0003  INSN3 <-- TP2, collect $regs
 167     ff0004  INSN4 <-- TP3, while-stepping 10 collect $regs
 168     ff0005  INSN5
 169
 170    Notice that when instruction INSN5 is reached, the while-stepping
 171    actions of both TP1 and TP3 are still being collected, and that TP2
 172    had been collected meanwhile.  The whole range of ff0001-ff0005
 173    should be single-stepped, due to at least TP1's while-stepping
 174    action covering the whole range.
 175
 176    On the other hand, the same tracepoint with a while-stepping action
 177    may be hit by more than one thread simultaneously, hence we can't
 178    keep the current step count in the tracepoint itself.
 179
 180    This is the head of the list of the states of `while-stepping'
 181    tracepoint actions this thread is now collecting; NULL if empty.
 182    Each item in the list holds the current step of the while-stepping
 183    action.  */
 184   struct wstep_state *while_stepping;
 185 };
 186
 187 struct dll_info
 188 {
 189   struct inferior_list_entry entry;
 190   char *name;
 191   CORE_ADDR base_addr;
 192 };
 193
 194 struct sym_cache;
 195 struct breakpoint;
 196 struct raw_breakpoint;
 197 struct fast_tracepoint_jump;
 198 struct process_info_private;
 199
 200 struct process_info
 201 {
 202   struct inferior_list_entry head;
 203
 204   /* Nonzero if this child process was attached rather than
 205      spawned.  */
 206   int attached;
 207
 208   /* True if GDB asked us to detach from this process, but we remained
 209      attached anyway.  */
 210   int gdb_detached;
 211
 212   /* The symbol cache.  */
 213   struct sym_cache *symbol_cache;
 214
 215   /* The list of memory breakpoints.  */
 216   struct breakpoint *breakpoints;
 217
 218   /* The list of raw memory breakpoints.  */
 219   struct raw_breakpoint *raw_breakpoints;
 220
 221   /* The list of installed fast tracepoints.  */
 222   struct fast_tracepoint_jump *fast_tracepoint_jumps;
 223
 224   /* Private target data.  */
 225   struct process_info_private *private;
 226 };
 227
 228 /* Return a pointer to the process that corresponds to the current
 229    thread (current_inferior).  It is an error to call this if there is
 230    no current thread selected.  */
 231
 232 struct process_info *current_process (void);
 233 struct process_info *get_thread_process (struct thread_info *);
 234
 235 /* Target-specific functions */
 236
 237 void initialize_low ();
 238
 239 /* From inferiors.c.  */
 240
 241 extern struct inferior_list all_processes;
 242 extern struct inferior_list all_threads;
 243 extern struct inferior_list all_dlls;
 244 extern int dlls_changed;
 245 extern void clear_dlls (void);
 246
 247 void add_inferior_to_list (struct inferior_list *list,
 248                            struct inferior_list_entry *new_inferior);
 249 void for_each_inferior (struct inferior_list *list,
 250                         void (*action) (struct inferior_list_entry *));
 251
 252 extern struct thread_info *current_inferior;
 253 void remove_inferior (struct inferior_list *list,
 254                       struct inferior_list_entry *entry);
 255 void remove_thread (struct thread_info *thread);
 256 void add_thread (ptid_t ptid, void *target_data);
 257
 258 struct process_info *add_process (int pid, int attached);
 259 void remove_process (struct process_info *process);
 260 struct process_info *find_process_pid (int pid);
 261 int have_started_inferiors_p (void);
 262 int have_attached_inferiors_p (void);
 263
 264 struct thread_info *find_thread_ptid (ptid_t ptid);
 265
 266 ptid_t thread_id_to_gdb_id (ptid_t);
 267 ptid_t thread_to_gdb_id (struct thread_info *);
 268 ptid_t gdb_id_to_thread_id (ptid_t);
 269 struct thread_info *gdb_id_to_thread (unsigned int);
 270 void clear_inferiors (void);
 271 struct inferior_list_entry *find_inferior
 272      (struct inferior_list *,
 273       int (*func) (struct inferior_list_entry *,
 274                    void *),
 275       void *arg);
 276 struct inferior_list_entry *find_inferior_id (struct inferior_list *list,
 277                                               ptid_t id);
 278 void *inferior_target_data (struct thread_info *);
 279 void set_inferior_target_data (struct thread_info *, void *);
 280 void *inferior_regcache_data (struct thread_info *);
 281 void set_inferior_regcache_data (struct thread_info *, void *);
 282
 283 void loaded_dll (const char *name, CORE_ADDR base_addr);
 284 void unloaded_dll (const char *name, CORE_ADDR base_addr);
 285
 286 /* Public variables in server.c */
 287
 288 extern ptid_t cont_thread;
 289 extern ptid_t general_thread;
 290
 291 extern int server_waiting;
 292 extern int debug_threads;
 293 extern int debug_hw_points;
 294 extern int pass_signals[];
 295
 296 extern jmp_buf toplevel;
 297
 298 extern int disable_packet_vCont;
 299 extern int disable_packet_Tthread;
 300 extern int disable_packet_qC;
 301 extern int disable_packet_qfThreadInfo;
 302
 303 extern int run_once;
 304 extern int multi_process;
 305 extern int non_stop;
 306
 307 extern int disable_randomization;
 308
 309 #if USE_WIN32API
 310 #include <winsock2.h>
 311 typedef SOCKET gdb_fildes_t;
 312 #else
 313 typedef int gdb_fildes_t;
 314 #endif
 315
 316 /* Functions from event-loop.c.  */
 317 typedef void *gdb_client_data;
 318 typedef int (handler_func) (int, gdb_client_data);
 319 typedef int (callback_handler_func) (gdb_client_data);
 320
 321 extern void delete_file_handler (gdb_fildes_t fd);
 322 extern void add_file_handler (gdb_fildes_t fd, handler_func *proc,
 323                               gdb_client_data client_data);
 324 extern int append_callback_event (callback_handler_func *proc,
 325                                    gdb_client_data client_data);
 326 extern void delete_callback_event (int id);
 327
 328 extern void start_event_loop (void);
 329
 330 /* Functions from server.c.  */
 331 extern int handle_serial_event (int err, gdb_client_data client_data);
 332 extern int handle_target_event (int err, gdb_client_data client_data);
 333
 334 extern void push_event (ptid_t ptid, struct target_waitstatus *status);
 335
 336 /* Functions from hostio.c.  */
 337 extern int handle_vFile (char *, int, int *);
 338
 339 /* Functions from hostio-errno.c.  */
 340 extern void hostio_last_error_from_errno (char *own_buf);
 341
 342 /* From remote-utils.c */
 343
 344 extern int remote_debug;
 345 extern int noack_mode;
 346 extern int transport_is_reliable;
 347
 348 int gdb_connected (void);
 349
 350 #define STDIO_CONNECTION_NAME "stdio"
 351 int remote_connection_is_stdio (void);
 352
 353 ptid_t read_ptid (char *buf, char **obuf);
 354 char *write_ptid (char *buf, ptid_t ptid);
 355
 356 int putpkt (char *buf);
 357 int putpkt_binary (char *buf, int len);
 358 int putpkt_notif (char *buf);
 359 int getpkt (char *buf);
 360 void remote_prepare (char *name);
 361 void remote_open (char *name);
 362 void remote_close (void);
 363 void write_ok (char *buf);
 364 void write_enn (char *buf);
 365 void initialize_async_io (void);
 366 void enable_async_io (void);
 367 void disable_async_io (void);
 368 void check_remote_input_interrupt_request (void);
 369 void convert_ascii_to_int (const char *from, unsigned char *to, int n);
 370 void convert_int_to_ascii (const unsigned char *from, char *to, int n);
 371 void new_thread_notify (int id);
 372 void dead_thread_notify (int id);
 373 void prepare_resume_reply (char *buf, ptid_t ptid,
 374                            struct target_waitstatus *status);
 375
 376 const char *decode_address_to_semicolon (CORE_ADDR *addrp, const char *start);
 377 void decode_address (CORE_ADDR *addrp, const char *start, int len);
 378 void decode_m_packet (char *from, CORE_ADDR * mem_addr_ptr,
 379                       unsigned int *len_ptr);
 380 void decode_M_packet (char *from, CORE_ADDR * mem_addr_ptr,
 381                       unsigned int *len_ptr, unsigned char **to_p);
 382 int decode_X_packet (char *from, int packet_len, CORE_ADDR * mem_addr_ptr,
 383                      unsigned int *len_ptr, unsigned char **to_p);
 384 int decode_xfer_write (char *buf, int packet_len,
 385                        CORE_ADDR *offset, unsigned int *len,
 386                        unsigned char *data);
 387 int decode_search_memory_packet (const char *buf, int packet_len,
 388                                  CORE_ADDR *start_addrp,
 389                                  CORE_ADDR *search_space_lenp,
 390                                  gdb_byte *pattern,
 391                                  unsigned int *pattern_lenp);
 392
 393 int unhexify (char *bin, const char *hex, int count);
 394 int hexify (char *hex, const char *bin, int count);
 395 int remote_escape_output (const gdb_byte *buffer, int len,
 396                           gdb_byte *out_buf, int *out_len,
 397                           int out_maxlen);
 398 char *unpack_varlen_hex (char *buff,  ULONGEST *result);
 399
 400 void clear_symbol_cache (struct sym_cache **symcache_p);
 401 int look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb);
 402
 403 int relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc);
 404
 405 void monitor_output (const char *msg);
 406
 407 /* Functions from utils.c */
 408 #include "common-utils.h"
 409
 410 void *xmalloc (size_t) ATTR_MALLOC;
 411 void *xrealloc (void *, size_t);
 412 void *xcalloc (size_t, size_t) ATTR_MALLOC;
 413 char *xstrdup (const char *) ATTR_MALLOC;
 414 int xsnprintf (char *str, size_t size, const char *format, ...)
 415   ATTR_FORMAT (printf, 3, 4);;
 416 void freeargv (char **argv);
 417 void perror_with_name (const char *string);
 418 void error (const char *string,...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2);
 419 void fatal (const char *string,...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2);
 420 void warning (const char *string,...) ATTR_FORMAT (printf, 1, 2);
 421 char *paddress (CORE_ADDR addr);
 422 char *pulongest (ULONGEST u);
 423 char *plongest (LONGEST l);
 424 char *phex_nz (ULONGEST l, int sizeof_l);
 425 char *pfildes (gdb_fildes_t fd);
 426
 427 #include "gdb_assert.h"
 428
 429 /* Maximum number of bytes to read/write at once.  The value here
 430    is chosen to fill up a packet (the headers account for the 32).  */
 431 #define MAXBUFBYTES(N) (((N)-32)/2)
 432
 433 /* Buffer sizes for transferring memory, registers, etc.   Set to a constant
 434    value to accomodate multiple register formats.  This value must be at least
 435    as large as the largest register set supported by gdbserver.  */
 436 #define PBUFSIZ 16384
 437
 438 /* Functions from tracepoint.c */
 439
 440 /* Size for a small buffer to report problems from the in-process
 441    agent back to GDBserver.  */
 442 #define IPA_BUFSIZ 100
 443
 444 void initialize_tracepoint (void);
 445
 446 extern int tracing;
 447 extern int disconnected_tracing;
 448
 449 void tracepoint_look_up_symbols (void);
 450
 451 void stop_tracing (void);
 452
 453 int handle_tracepoint_general_set (char *own_buf);
 454 int handle_tracepoint_query (char *own_buf);
 455
 456 int tracepoint_finished_step (struct thread_info *tinfo, CORE_ADDR stop_pc);
 457 int tracepoint_was_hit (struct thread_info *tinfo, CORE_ADDR stop_pc);
 458
 459 void release_while_stepping_state_list (struct thread_info *tinfo);
 460
 461 extern int current_traceframe;
 462
 463 int in_readonly_region (CORE_ADDR addr, ULONGEST length);
 464 int traceframe_read_mem (int tfnum, CORE_ADDR addr,
 465                          unsigned char *buf, ULONGEST length,
 466                          ULONGEST *nbytes);
 467 int fetch_traceframe_registers (int tfnum,
 468                                 struct regcache *regcache,
 469                                 int regnum);
 470
 471 int traceframe_read_sdata (int tfnum, ULONGEST offset,
 472                            unsigned char *buf, ULONGEST length,
 473                            ULONGEST *nbytes);
 474
 475 int traceframe_read_info (int tfnum, struct buffer *buffer);
 476
 477 /* If a thread is determined to be collecting a fast tracepoint, this
 478    structure holds the collect status.  */
 479
 480 struct fast_tpoint_collect_status
 481 {
 482   /* The tracepoint that is presently being collected.  */
 483   int tpoint_num;
 484   CORE_ADDR tpoint_addr;
 485
 486   /* The address range in the jump pad of where the original
 487      instruction the tracepoint jump was inserted was relocated
 488      to.  */
 489   CORE_ADDR adjusted_insn_addr;
 490   CORE_ADDR adjusted_insn_addr_end;
 491 };
 492
 493 int fast_tracepoint_collecting (CORE_ADDR thread_area,
 494                                 CORE_ADDR stop_pc,
 495                                 struct fast_tpoint_collect_status *status);
 496 void force_unlock_trace_buffer (void);
 497
 498 int handle_tracepoint_bkpts (struct thread_info *tinfo, CORE_ADDR stop_pc);
 499
 500 #ifdef IN_PROCESS_AGENT
 501 void initialize_low_tracepoint (void);
 502 void supply_fast_tracepoint_registers (struct regcache *regcache,
 503                                        const unsigned char *regs);
 504 void supply_static_tracepoint_registers (struct regcache *regcache,
 505                                          const unsigned char *regs,
 506                                          CORE_ADDR pc);
 507 void set_trampoline_buffer_space (CORE_ADDR begin, CORE_ADDR end,
 508                                   char *errmsg);
 509 #else
 510 void stop_tracing (void);
 511
 512 int claim_trampoline_space (ULONGEST used, CORE_ADDR *trampoline);
 513 int have_fast_tracepoint_trampoline_buffer (char *msgbuf);
 514 #endif
 515
 516 struct traceframe;
 517
 518 /* Do memory copies for bytecodes.  */
 519 /* Do the recording of memory blocks for actions and bytecodes.  */
 520
 521 int agent_mem_read (struct traceframe *tframe,
 522                     unsigned char *to, CORE_ADDR from,
 523                     ULONGEST len);
 524
 525 LONGEST agent_get_trace_state_variable_value (int num);
 526 void agent_set_trace_state_variable_value (int num, LONGEST val);
 527
 528 /* Record the value of a trace state variable.  */
 529
 530 int agent_tsv_read (struct traceframe *tframe, int n);
 531 int agent_mem_read_string (struct traceframe *tframe,
 532                            unsigned char *to,
 533                            CORE_ADDR from,
 534                            ULONGEST len);
 535
 536 /* Bytecode compilation function vector.  */
 537
 538 struct emit_ops
 539 {
 540   void (*emit_prologue) (void);
 541   void (*emit_epilogue) (void);
 542   void (*emit_add) (void);
 543   void (*emit_sub) (void);
 544   void (*emit_mul) (void);
 545   void (*emit_lsh) (void);
 546   void (*emit_rsh_signed) (void);
 547   void (*emit_rsh_unsigned) (void);
 548   void (*emit_ext) (int arg);
 549   void (*emit_log_not) (void);
 550   void (*emit_bit_and) (void);
 551   void (*emit_bit_or) (void);
 552   void (*emit_bit_xor) (void);
 553   void (*emit_bit_not) (void);
 554   void (*emit_equal) (void);
 555   void (*emit_less_signed) (void);
 556   void (*emit_less_unsigned) (void);
 557   void (*emit_ref) (int size);
 558   void (*emit_if_goto) (int *offset_p, int *size_p);
 559   void (*emit_goto) (int *offset_p, int *size_p);
 560   void (*write_goto_address) (CORE_ADDR from, CORE_ADDR to, int size);
 561   void (*emit_const) (LONGEST num);
 562   void (*emit_call) (CORE_ADDR fn);
 563   void (*emit_reg) (int reg);
 564   void (*emit_pop) (void);
 565   void (*emit_stack_flush) (void);
 566   void (*emit_zero_ext) (int arg);
 567   void (*emit_swap) (void);
 568   void (*emit_stack_adjust) (int n);
 569
 570   /* Emit code for a generic function that takes one fixed integer
 571      argument and returns a 64-bit int (for instance, tsv getter).  */
 572   void (*emit_int_call_1) (CORE_ADDR fn, int arg1);
 573
 574   /* Emit code for a generic function that takes one fixed integer
 575      argument and a 64-bit int from the top of the stack, and returns
 576      nothing (for instance, tsv setter).  */
 577   void (*emit_void_call_2) (CORE_ADDR fn, int arg1);
 578
 579   /* Emit code specialized for common combinations of compare followed
 580      by a goto.  */
 581   void (*emit_eq_goto) (int *offset_p, int *size_p);
 582   void (*emit_ne_goto) (int *offset_p, int *size_p);
 583   void (*emit_lt_goto) (int *offset_p, int *size_p);
 584   void (*emit_le_goto) (int *offset_p, int *size_p);
 585   void (*emit_gt_goto) (int *offset_p, int *size_p);
 586   void (*emit_ge_goto) (int *offset_p, int *size_p);
 587 };
 588
 589 /* Returns the address of the get_raw_reg function in the IPA.  */
 590 CORE_ADDR get_raw_reg_func_addr (void);
 591 /* Returns the address of the get_trace_state_variable_value
 592    function in the IPA.  */
 593 CORE_ADDR get_get_tsv_func_addr (void);
 594 /* Returns the address of the set_trace_state_variable_value
 595    function in the IPA.  */
 596 CORE_ADDR get_set_tsv_func_addr (void);
 597
 598 CORE_ADDR current_insn_ptr;
 599 int emit_error;
 600
 601 /* Version information, from version.c.  */
 602 extern const char version[];
 603 extern const char host_name[];
 604
 605 #endif /* SERVER_H */