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 extern int program_signals[];
 296 extern int program_signals_p;
 297
 298 extern jmp_buf toplevel;
 299
 300 extern int disable_packet_vCont;
 301 extern int disable_packet_Tthread;
 302 extern int disable_packet_qC;
 303 extern int disable_packet_qfThreadInfo;
 304
 305 extern int run_once;
 306 extern int multi_process;
 307 extern int non_stop;
 308
 309 extern int disable_randomization;
 310
 311 #if USE_WIN32API
 312 #include <winsock2.h>
 313 typedef SOCKET gdb_fildes_t;
 314 #else
 315 typedef int gdb_fildes_t;
 316 #endif
 317
 318 /* Functions from event-loop.c.  */
 319 typedef void *gdb_client_data;
 320 typedef int (handler_func) (int, gdb_client_data);
 321 typedef int (callback_handler_func) (gdb_client_data);
 322
 323 extern void delete_file_handler (gdb_fildes_t fd);
 324 extern void add_file_handler (gdb_fildes_t fd, handler_func *proc,
 325                               gdb_client_data client_data);
 326 extern int append_callback_event (callback_handler_func *proc,
 327                                    gdb_client_data client_data);
 328 extern void delete_callback_event (int id);
 329
 330 extern void start_event_loop (void);
 331
 332 /* Functions from server.c.  */
 333 extern int handle_serial_event (int err, gdb_client_data client_data);
 334 extern int handle_target_event (int err, gdb_client_data client_data);
 335
 336 extern void push_event (ptid_t ptid, struct target_waitstatus *status);
 337
 338 /* Functions from hostio.c.  */
 339 extern int handle_vFile (char *, int, int *);
 340
 341 /* Functions from hostio-errno.c.  */
 342 extern void hostio_last_error_from_errno (char *own_buf);
 343
 344 /* From remote-utils.c */
 345
 346 extern int remote_debug;
 347 extern int noack_mode;
 348 extern int transport_is_reliable;
 349
 350 int gdb_connected (void);
 351
 352 #define STDIO_CONNECTION_NAME "stdio"
 353 int remote_connection_is_stdio (void);
 354
 355 ptid_t read_ptid (char *buf, char **obuf);
 356 char *write_ptid (char *buf, ptid_t ptid);
 357
 358 int putpkt (char *buf);
 359 int putpkt_binary (char *buf, int len);
 360 int putpkt_notif (char *buf);
 361 int getpkt (char *buf);
 362 void remote_prepare (char *name);
 363 void remote_open (char *name);
 364 void remote_close (void);
 365 void write_ok (char *buf);
 366 void write_enn (char *buf);
 367 void initialize_async_io (void);
 368 void enable_async_io (void);
 369 void disable_async_io (void);
 370 void check_remote_input_interrupt_request (void);
 371 void convert_ascii_to_int (const char *from, unsigned char *to, int n);
 372 void convert_int_to_ascii (const unsigned char *from, char *to, int n);
 373 void new_thread_notify (int id);
 374 void dead_thread_notify (int id);
 375 void prepare_resume_reply (char *buf, ptid_t ptid,
 376                            struct target_waitstatus *status);
 377
 378 const char *decode_address_to_semicolon (CORE_ADDR *addrp, const char *start);
 379 void decode_address (CORE_ADDR *addrp, const char *start, int len);
 380 void decode_m_packet (char *from, CORE_ADDR * mem_addr_ptr,
 381                       unsigned int *len_ptr);
 382 void decode_M_packet (char *from, CORE_ADDR * mem_addr_ptr,
 383                       unsigned int *len_ptr, unsigned char **to_p);
 384 int decode_X_packet (char *from, int packet_len, CORE_ADDR * mem_addr_ptr,
 385                      unsigned int *len_ptr, unsigned char **to_p);
 386 int decode_xfer_write (char *buf, int packet_len,
 387                        CORE_ADDR *offset, unsigned int *len,
 388                        unsigned char *data);
 389 int decode_search_memory_packet (const char *buf, int packet_len,
 390                                  CORE_ADDR *start_addrp,
 391                                  CORE_ADDR *search_space_lenp,
 392                                  gdb_byte *pattern,
 393                                  unsigned int *pattern_lenp);
 394
 395 int unhexify (char *bin, const char *hex, int count);
 396 int hexify (char *hex, const char *bin, int count);
 397 int remote_escape_output (const gdb_byte *buffer, int len,
 398                           gdb_byte *out_buf, int *out_len,
 399                           int out_maxlen);
 400 char *unpack_varlen_hex (char *buff,  ULONGEST *result);
 401
 402 void clear_symbol_cache (struct sym_cache **symcache_p);
 403 int look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb);
 404
 405 int relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc);
 406
 407 void monitor_output (const char *msg);
 408
 409 /* Functions from utils.c */
 410 #include "common-utils.h"
 411
 412 void *xmalloc (size_t) ATTR_MALLOC;
 413 void *xrealloc (void *, size_t);
 414 void *xcalloc (size_t, size_t) ATTR_MALLOC;
 415 char *xstrdup (const char *) ATTR_MALLOC;
 416 int xsnprintf (char *str, size_t size, const char *format, ...)
 417   ATTR_FORMAT (printf, 3, 4);;
 418 void freeargv (char **argv);
 419 void perror_with_name (const char *string);
 420 void error (const char *string,...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2);
 421 void fatal (const char *string,...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2);
 422 void warning (const char *string,...) ATTR_FORMAT (printf, 1, 2);
 423 char *paddress (CORE_ADDR addr);
 424 char *pulongest (ULONGEST u);
 425 char *plongest (LONGEST l);
 426 char *phex_nz (ULONGEST l, int sizeof_l);
 427 char *pfildes (gdb_fildes_t fd);
 428
 429 #include "gdb_assert.h"
 430
 431 /* Maximum number of bytes to read/write at once.  The value here
 432    is chosen to fill up a packet (the headers account for the 32).  */
 433 #define MAXBUFBYTES(N) (((N)-32)/2)
 434
 435 /* Buffer sizes for transferring memory, registers, etc.   Set to a constant
 436    value to accomodate multiple register formats.  This value must be at least
 437    as large as the largest register set supported by gdbserver.  */
 438 #define PBUFSIZ 16384
 439
 440 /* Functions from tracepoint.c */
 441
 442 /* Size for a small buffer to report problems from the in-process
 443    agent back to GDBserver.  */
 444 #define IPA_BUFSIZ 100
 445
 446 void initialize_tracepoint (void);
 447
 448 extern int tracing;
 449 extern int disconnected_tracing;
 450
 451 void tracepoint_look_up_symbols (void);
 452
 453 void stop_tracing (void);
 454
 455 int handle_tracepoint_general_set (char *own_buf);
 456 int handle_tracepoint_query (char *own_buf);
 457
 458 int tracepoint_finished_step (struct thread_info *tinfo, CORE_ADDR stop_pc);
 459 int tracepoint_was_hit (struct thread_info *tinfo, CORE_ADDR stop_pc);
 460
 461 void release_while_stepping_state_list (struct thread_info *tinfo);
 462
 463 extern int current_traceframe;
 464
 465 int in_readonly_region (CORE_ADDR addr, ULONGEST length);
 466 int traceframe_read_mem (int tfnum, CORE_ADDR addr,
 467                          unsigned char *buf, ULONGEST length,
 468                          ULONGEST *nbytes);
 469 int fetch_traceframe_registers (int tfnum,
 470                                 struct regcache *regcache,
 471                                 int regnum);
 472
 473 int traceframe_read_sdata (int tfnum, ULONGEST offset,
 474                            unsigned char *buf, ULONGEST length,
 475                            ULONGEST *nbytes);
 476
 477 int traceframe_read_info (int tfnum, struct buffer *buffer);
 478
 479 /* If a thread is determined to be collecting a fast tracepoint, this
 480    structure holds the collect status.  */
 481
 482 struct fast_tpoint_collect_status
 483 {
 484   /* The tracepoint that is presently being collected.  */
 485   int tpoint_num;
 486   CORE_ADDR tpoint_addr;
 487
 488   /* The address range in the jump pad of where the original
 489      instruction the tracepoint jump was inserted was relocated
 490      to.  */
 491   CORE_ADDR adjusted_insn_addr;
 492   CORE_ADDR adjusted_insn_addr_end;
 493 };
 494
 495 int fast_tracepoint_collecting (CORE_ADDR thread_area,
 496                                 CORE_ADDR stop_pc,
 497                                 struct fast_tpoint_collect_status *status);
 498 void force_unlock_trace_buffer (void);
 499
 500 int handle_tracepoint_bkpts (struct thread_info *tinfo, CORE_ADDR stop_pc);
 501
 502 #ifdef IN_PROCESS_AGENT
 503 void initialize_low_tracepoint (void);
 504 void supply_fast_tracepoint_registers (struct regcache *regcache,
 505                                        const unsigned char *regs);
 506 void supply_static_tracepoint_registers (struct regcache *regcache,
 507                                          const unsigned char *regs,
 508                                          CORE_ADDR pc);
 509 void set_trampoline_buffer_space (CORE_ADDR begin, CORE_ADDR end,
 510                                   char *errmsg);
 511 #else
 512 void stop_tracing (void);
 513
 514 int claim_trampoline_space (ULONGEST used, CORE_ADDR *trampoline);
 515 int have_fast_tracepoint_trampoline_buffer (char *msgbuf);
 516 #endif
 517
 518 struct traceframe;
 519
 520 /* Do memory copies for bytecodes.  */
 521 /* Do the recording of memory blocks for actions and bytecodes.  */
 522
 523 int agent_mem_read (struct traceframe *tframe,
 524                     unsigned char *to, CORE_ADDR from,
 525                     ULONGEST len);
 526
 527 LONGEST agent_get_trace_state_variable_value (int num);
 528 void agent_set_trace_state_variable_value (int num, LONGEST val);
 529
 530 /* Record the value of a trace state variable.  */
 531
 532 int agent_tsv_read (struct traceframe *tframe, int n);
 533 int agent_mem_read_string (struct traceframe *tframe,
 534                            unsigned char *to,
 535                            CORE_ADDR from,
 536                            ULONGEST len);
 537
 538 /* Bytecode compilation function vector.  */
 539
 540 struct emit_ops
 541 {
 542   void (*emit_prologue) (void);
 543   void (*emit_epilogue) (void);
 544   void (*emit_add) (void);
 545   void (*emit_sub) (void);
 546   void (*emit_mul) (void);
 547   void (*emit_lsh) (void);
 548   void (*emit_rsh_signed) (void);
 549   void (*emit_rsh_unsigned) (void);
 550   void (*emit_ext) (int arg);
 551   void (*emit_log_not) (void);
 552   void (*emit_bit_and) (void);
 553   void (*emit_bit_or) (void);
 554   void (*emit_bit_xor) (void);
 555   void (*emit_bit_not) (void);
 556   void (*emit_equal) (void);
 557   void (*emit_less_signed) (void);
 558   void (*emit_less_unsigned) (void);
 559   void (*emit_ref) (int size);
 560   void (*emit_if_goto) (int *offset_p, int *size_p);
 561   void (*emit_goto) (int *offset_p, int *size_p);
 562   void (*write_goto_address) (CORE_ADDR from, CORE_ADDR to, int size);
 563   void (*emit_const) (LONGEST num);
 564   void (*emit_call) (CORE_ADDR fn);
 565   void (*emit_reg) (int reg);
 566   void (*emit_pop) (void);
 567   void (*emit_stack_flush) (void);
 568   void (*emit_zero_ext) (int arg);
 569   void (*emit_swap) (void);
 570   void (*emit_stack_adjust) (int n);
 571
 572   /* Emit code for a generic function that takes one fixed integer
 573      argument and returns a 64-bit int (for instance, tsv getter).  */
 574   void (*emit_int_call_1) (CORE_ADDR fn, int arg1);
 575
 576   /* Emit code for a generic function that takes one fixed integer
 577      argument and a 64-bit int from the top of the stack, and returns
 578      nothing (for instance, tsv setter).  */
 579   void (*emit_void_call_2) (CORE_ADDR fn, int arg1);
 580
 581   /* Emit code specialized for common combinations of compare followed
 582      by a goto.  */
 583   void (*emit_eq_goto) (int *offset_p, int *size_p);
 584   void (*emit_ne_goto) (int *offset_p, int *size_p);
 585   void (*emit_lt_goto) (int *offset_p, int *size_p);
 586   void (*emit_le_goto) (int *offset_p, int *size_p);
 587   void (*emit_gt_goto) (int *offset_p, int *size_p);
 588   void (*emit_ge_goto) (int *offset_p, int *size_p);
 589 };
 590
 591 /* Returns the address of the get_raw_reg function in the IPA.  */
 592 CORE_ADDR get_raw_reg_func_addr (void);
 593 /* Returns the address of the get_trace_state_variable_value
 594    function in the IPA.  */
 595 CORE_ADDR get_get_tsv_func_addr (void);
 596 /* Returns the address of the set_trace_state_variable_value
 597    function in the IPA.  */
 598 CORE_ADDR get_set_tsv_func_addr (void);
 599
 600 CORE_ADDR current_insn_ptr;
 601 int emit_error;
 602
 603 /* Version information, from version.c.  */
 604 extern const char version[];
 605 extern const char host_name[];
 606
 607 #endif /* SERVER_H */