gdb/gdbserver/server.h

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