2012-02-24 Luis Machado <lgustavo@codesourcery>
[external/binutils.git] / 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 void add_pid_to_list (struct inferior_list *list, unsigned long pid);
283 int pull_pid_from_list (struct inferior_list *list, unsigned long pid);
284
285 void loaded_dll (const char *name, CORE_ADDR base_addr);
286 void unloaded_dll (const char *name, CORE_ADDR base_addr);
287
288 /* Public variables in server.c */
289
290 extern ptid_t cont_thread;
291 extern ptid_t general_thread;
292
293 extern int server_waiting;
294 extern int debug_threads;
295 extern int debug_hw_points;
296 extern int pass_signals[];
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 int in_process_agent_loaded (void);
447
448 void initialize_tracepoint (void);
449
450 extern int tracing;
451 extern int disconnected_tracing;
452
453 void tracepoint_look_up_symbols (void);
454
455 void stop_tracing (void);
456
457 int handle_tracepoint_general_set (char *own_buf);
458 int handle_tracepoint_query (char *own_buf);
459
460 int tracepoint_finished_step (struct thread_info *tinfo, CORE_ADDR stop_pc);
461 int tracepoint_was_hit (struct thread_info *tinfo, CORE_ADDR stop_pc);
462
463 void release_while_stepping_state_list (struct thread_info *tinfo);
464
465 extern int current_traceframe;
466
467 int in_readonly_region (CORE_ADDR addr, ULONGEST length);
468 int traceframe_read_mem (int tfnum, CORE_ADDR addr,
469                          unsigned char *buf, ULONGEST length,
470                          ULONGEST *nbytes);
471 int fetch_traceframe_registers (int tfnum,
472                                 struct regcache *regcache,
473                                 int regnum);
474
475 int traceframe_read_sdata (int tfnum, ULONGEST offset,
476                            unsigned char *buf, ULONGEST length,
477                            ULONGEST *nbytes);
478
479 int traceframe_read_info (int tfnum, struct buffer *buffer);
480
481 /* If a thread is determined to be collecting a fast tracepoint, this
482    structure holds the collect status.  */
483
484 struct fast_tpoint_collect_status
485 {
486   /* The tracepoint that is presently being collected.  */
487   int tpoint_num;
488   CORE_ADDR tpoint_addr;
489
490   /* The address range in the jump pad of where the original
491      instruction the tracepoint jump was inserted was relocated
492      to.  */
493   CORE_ADDR adjusted_insn_addr;
494   CORE_ADDR adjusted_insn_addr_end;
495 };
496
497 int fast_tracepoint_collecting (CORE_ADDR thread_area,
498                                 CORE_ADDR stop_pc,
499                                 struct fast_tpoint_collect_status *status);
500 void force_unlock_trace_buffer (void);
501
502 int handle_tracepoint_bkpts (struct thread_info *tinfo, CORE_ADDR stop_pc);
503
504 #ifdef IN_PROCESS_AGENT
505 void initialize_low_tracepoint (void);
506 void supply_fast_tracepoint_registers (struct regcache *regcache,
507                                        const unsigned char *regs);
508 void supply_static_tracepoint_registers (struct regcache *regcache,
509                                          const unsigned char *regs,
510                                          CORE_ADDR pc);
511 void set_trampoline_buffer_space (CORE_ADDR begin, CORE_ADDR end,
512                                   char *errmsg);
513 #else
514 void stop_tracing (void);
515
516 int claim_trampoline_space (ULONGEST used, CORE_ADDR *trampoline);
517 int have_fast_tracepoint_trampoline_buffer (char *msgbuf);
518 #endif
519
520 struct traceframe;
521
522 /* Do memory copies for bytecodes.  */
523 /* Do the recording of memory blocks for actions and bytecodes.  */
524
525 int agent_mem_read (struct traceframe *tframe,
526                     unsigned char *to, CORE_ADDR from,
527                     ULONGEST len);
528
529 LONGEST agent_get_trace_state_variable_value (int num);
530 void agent_set_trace_state_variable_value (int num, LONGEST val);
531
532 /* Record the value of a trace state variable.  */
533
534 int agent_tsv_read (struct traceframe *tframe, int n);
535 int agent_mem_read_string (struct traceframe *tframe,
536                            unsigned char *to,
537                            CORE_ADDR from,
538                            ULONGEST len);
539
540 /* Bytecode compilation function vector.  */
541
542 struct emit_ops
543 {
544   void (*emit_prologue) (void);
545   void (*emit_epilogue) (void);
546   void (*emit_add) (void);
547   void (*emit_sub) (void);
548   void (*emit_mul) (void);
549   void (*emit_lsh) (void);
550   void (*emit_rsh_signed) (void);
551   void (*emit_rsh_unsigned) (void);
552   void (*emit_ext) (int arg);
553   void (*emit_log_not) (void);
554   void (*emit_bit_and) (void);
555   void (*emit_bit_or) (void);
556   void (*emit_bit_xor) (void);
557   void (*emit_bit_not) (void);
558   void (*emit_equal) (void);
559   void (*emit_less_signed) (void);
560   void (*emit_less_unsigned) (void);
561   void (*emit_ref) (int size);
562   void (*emit_if_goto) (int *offset_p, int *size_p);
563   void (*emit_goto) (int *offset_p, int *size_p);
564   void (*write_goto_address) (CORE_ADDR from, CORE_ADDR to, int size);
565   void (*emit_const) (LONGEST num);
566   void (*emit_call) (CORE_ADDR fn);
567   void (*emit_reg) (int reg);
568   void (*emit_pop) (void);
569   void (*emit_stack_flush) (void);
570   void (*emit_zero_ext) (int arg);
571   void (*emit_swap) (void);
572   void (*emit_stack_adjust) (int n);
573
574   /* Emit code for a generic function that takes one fixed integer
575      argument and returns a 64-bit int (for instance, tsv getter).  */
576   void (*emit_int_call_1) (CORE_ADDR fn, int arg1);
577
578   /* Emit code for a generic function that takes one fixed integer
579      argument and a 64-bit int from the top of the stack, and returns
580      nothing (for instance, tsv setter).  */
581   void (*emit_void_call_2) (CORE_ADDR fn, int arg1);
582
583   /* Emit code specialized for common combinations of compare followed
584      by a goto.  */
585   void (*emit_eq_goto) (int *offset_p, int *size_p);
586   void (*emit_ne_goto) (int *offset_p, int *size_p);
587   void (*emit_lt_goto) (int *offset_p, int *size_p);
588   void (*emit_le_goto) (int *offset_p, int *size_p);
589   void (*emit_gt_goto) (int *offset_p, int *size_p);
590   void (*emit_ge_goto) (int *offset_p, int *size_p);
591 };
592
593 /* Returns the address of the get_raw_reg function in the IPA.  */
594 CORE_ADDR get_raw_reg_func_addr (void);
595 /* Returns the address of the get_trace_state_variable_value
596    function in the IPA.  */
597 CORE_ADDR get_get_tsv_func_addr (void);
598 /* Returns the address of the set_trace_state_variable_value
599    function in the IPA.  */
600 CORE_ADDR get_set_tsv_func_addr (void);
601
602 CORE_ADDR current_insn_ptr;
603 int emit_error;
604
605 /* Version information, from version.c.  */
606 extern const char version[];
607 extern const char host_name[];
608
609 #endif /* SERVER_H */