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