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 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
  45 #if !HAVE_DECL_STRERROR
  46 #ifndef strerror
  47 extern char *strerror (int);    /* X3.159-1989  4.11.6.2 */
  48 #endif
  49 #endif
  50
  51 #if !HAVE_DECL_PERROR
  52 #ifndef perror
  53 extern void perror (const char *);
  54 #endif
  55 #endif
  56
  57 #if !HAVE_DECL_MEMMEM
  58 extern void *memmem (const void *, size_t , const void *, size_t);
  59 #endif
  60
  61 #ifndef ATTR_NORETURN
  62 #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7))
  63 #define ATTR_NORETURN __attribute__ ((noreturn))
  64 #else
  65 #define ATTR_NORETURN           /* nothing */
  66 #endif
  67 #endif
  68
  69 #ifndef ATTR_FORMAT
  70 #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 4))
  71 #define ATTR_FORMAT(type, x, y) __attribute__ ((format(type, x, y)))
  72 #else
  73 #define ATTR_FORMAT(type, x, y) /* nothing */
  74 #endif
  75 #endif
  76
  77 #ifndef ATTR_MALLOC
  78 #if defined(__GNUC__) && (__GNUC__ >= 3)
  79 #define ATTR_MALLOC __attribute__ ((__malloc__))
  80 #else
  81 #define ATTR_MALLOC             /* nothing */
  82 #endif
  83 #endif
  84
  85 /* A type used for binary buffers.  */
  86 typedef unsigned char gdb_byte;
  87
  88 /* FIXME: This should probably be autoconf'd for.  It's an integer type at
  89    least the size of a (void *).  */
  90 typedef long long CORE_ADDR;
  91
  92 typedef long long LONGEST;
  93 typedef unsigned long long ULONGEST;
  94
  95 /* The ptid struct is a collection of the various "ids" necessary
  96    for identifying the inferior.  This consists of the process id
  97    (pid), thread id (tid), and other fields necessary for uniquely
  98    identifying the inferior process/thread being debugged.  When
  99    manipulating ptids, the constructors, accessors, and predicate
 100    declared in server.h should be used.  These are as follows:
 101
 102       ptid_build        - Make a new ptid from a pid, lwp, and tid.
 103       pid_to_ptid       - Make a new ptid from just a pid.
 104       ptid_get_pid      - Fetch the pid component of a ptid.
 105       ptid_get_lwp      - Fetch the lwp component of a ptid.
 106       ptid_get_tid      - Fetch the tid component of a ptid.
 107       ptid_equal        - Test to see if two ptids are equal.
 108
 109    Please do NOT access the struct ptid members directly (except, of
 110    course, in the implementation of the above ptid manipulation
 111    functions).  */
 112
 113 struct ptid
 114   {
 115     /* Process id */
 116     int pid;
 117
 118     /* Lightweight process id */
 119     long lwp;
 120
 121     /* Thread id */
 122     long tid;
 123   };
 124
 125 typedef struct ptid ptid_t;
 126
 127 /* The -1 ptid, often used to indicate either an error condition or a
 128    "don't care" condition, i.e, "run all threads".  */
 129 extern ptid_t minus_one_ptid;
 130
 131 /* The null or zero ptid, often used to indicate no process.  */
 132 extern ptid_t null_ptid;
 133
 134 /* Attempt to find and return an existing ptid with the given PID,
 135    LWP, and TID components.  If none exists, create a new one and
 136    return that.  */
 137 ptid_t ptid_build (int pid, long lwp, long tid);
 138
 139 /* Create a ptid from just a pid.  */
 140 ptid_t pid_to_ptid (int pid);
 141
 142 /* Fetch the pid (process id) component from a ptid.  */
 143 int ptid_get_pid (ptid_t ptid);
 144
 145 /* Fetch the lwp (lightweight process) component from a ptid.  */
 146 long ptid_get_lwp (ptid_t ptid);
 147
 148 /* Fetch the tid (thread id) component from a ptid.  */
 149 long ptid_get_tid (ptid_t ptid);
 150
 151 /* Compare two ptids to see if they are equal.  */
 152 extern int ptid_equal (ptid_t p1, ptid_t p2);
 153
 154 /* Return true if this ptid represents a process id.  */
 155 extern int ptid_is_pid (ptid_t ptid);
 156
 157 /* Generic information for tracking a list of ``inferiors'' - threads,
 158    processes, etc.  */
 159 struct inferior_list
 160 {
 161   struct inferior_list_entry *head;
 162   struct inferior_list_entry *tail;
 163 };
 164 struct inferior_list_entry
 165 {
 166   ptid_t id;
 167   struct inferior_list_entry *next;
 168 };
 169
 170 struct thread_info;
 171 struct process_info;
 172 struct regcache;
 173
 174 #include "regcache.h"
 175 #include "gdb/signals.h"
 176 #include "gdb_signals.h"
 177 #include "target.h"
 178 #include "mem-break.h"
 179
 180 struct thread_info
 181 {
 182   struct inferior_list_entry entry;
 183   void *target_data;
 184   void *regcache_data;
 185
 186   /* The last resume GDB requested on this thread.  */
 187   enum resume_kind last_resume_kind;
 188
 189   /* The last wait status reported for this thread.  */
 190   struct target_waitstatus last_status;
 191
 192   /* Given `while-stepping', a thread may be collecting data for more
 193      than one tracepoint simultaneously.  E.g.:
 194
 195     ff0001  INSN1 <-- TP1, while-stepping 10 collect $regs
 196     ff0002  INSN2
 197     ff0003  INSN3 <-- TP2, collect $regs
 198     ff0004  INSN4 <-- TP3, while-stepping 10 collect $regs
 199     ff0005  INSN5
 200
 201    Notice that when instruction INSN5 is reached, the while-stepping
 202    actions of both TP1 and TP3 are still being collected, and that TP2
 203    had been collected meanwhile.  The whole range of ff0001-ff0005
 204    should be single-stepped, due to at least TP1's while-stepping
 205    action covering the whole range.
 206
 207    On the other hand, the same tracepoint with a while-stepping action
 208    may be hit by more than one thread simultaneously, hence we can't
 209    keep the current step count in the tracepoint itself.
 210
 211    This is the head of the list of the states of `while-stepping'
 212    tracepoint actions this thread is now collecting; NULL if empty.
 213    Each item in the list holds the current step of the while-stepping
 214    action.  */
 215   struct wstep_state *while_stepping;
 216 };
 217
 218 struct dll_info
 219 {
 220   struct inferior_list_entry entry;
 221   char *name;
 222   CORE_ADDR base_addr;
 223 };
 224
 225 struct sym_cache;
 226 struct breakpoint;
 227 struct raw_breakpoint;
 228 struct fast_tracepoint_jump;
 229 struct process_info_private;
 230
 231 struct process_info
 232 {
 233   struct inferior_list_entry head;
 234
 235   /* Nonzero if this child process was attached rather than
 236      spawned.  */
 237   int attached;
 238
 239   /* True if GDB asked us to detach from this process, but we remained
 240      attached anyway.  */
 241   int gdb_detached;
 242
 243   /* The symbol cache.  */
 244   struct sym_cache *symbol_cache;
 245
 246   /* The list of memory breakpoints.  */
 247   struct breakpoint *breakpoints;
 248
 249   /* The list of raw memory breakpoints.  */
 250   struct raw_breakpoint *raw_breakpoints;
 251
 252   /* The list of installed fast tracepoints.  */
 253   struct fast_tracepoint_jump *fast_tracepoint_jumps;
 254
 255   /* Private target data.  */
 256   struct process_info_private *private;
 257 };
 258
 259 /* Return a pointer to the process that corresponds to the current
 260    thread (current_inferior).  It is an error to call this if there is
 261    no current thread selected.  */
 262
 263 struct process_info *current_process (void);
 264 struct process_info *get_thread_process (struct thread_info *);
 265
 266 /* Target-specific functions */
 267
 268 void initialize_low ();
 269
 270 /* From inferiors.c.  */
 271
 272 extern struct inferior_list all_processes;
 273 extern struct inferior_list all_threads;
 274 extern struct inferior_list all_dlls;
 275 extern int dlls_changed;
 276
 277 void initialize_inferiors (void);
 278
 279 void add_inferior_to_list (struct inferior_list *list,
 280                            struct inferior_list_entry *new_inferior);
 281 void for_each_inferior (struct inferior_list *list,
 282                         void (*action) (struct inferior_list_entry *));
 283
 284 extern struct thread_info *current_inferior;
 285 void remove_inferior (struct inferior_list *list,
 286                       struct inferior_list_entry *entry);
 287 void remove_thread (struct thread_info *thread);
 288 void add_thread (ptid_t ptid, void *target_data);
 289
 290 struct process_info *add_process (int pid, int attached);
 291 void remove_process (struct process_info *process);
 292 struct process_info *find_process_pid (int pid);
 293 int have_started_inferiors_p (void);
 294 int have_attached_inferiors_p (void);
 295
 296 struct thread_info *find_thread_ptid (ptid_t ptid);
 297
 298 ptid_t thread_id_to_gdb_id (ptid_t);
 299 ptid_t thread_to_gdb_id (struct thread_info *);
 300 ptid_t gdb_id_to_thread_id (ptid_t);
 301 struct thread_info *gdb_id_to_thread (unsigned int);
 302 void clear_inferiors (void);
 303 struct inferior_list_entry *find_inferior
 304      (struct inferior_list *,
 305       int (*func) (struct inferior_list_entry *,
 306                    void *),
 307       void *arg);
 308 struct inferior_list_entry *find_inferior_id (struct inferior_list *list,
 309                                               ptid_t id);
 310 void *inferior_target_data (struct thread_info *);
 311 void set_inferior_target_data (struct thread_info *, void *);
 312 void *inferior_regcache_data (struct thread_info *);
 313 void set_inferior_regcache_data (struct thread_info *, void *);
 314 void add_pid_to_list (struct inferior_list *list, unsigned long pid);
 315 int pull_pid_from_list (struct inferior_list *list, unsigned long pid);
 316
 317 void loaded_dll (const char *name, CORE_ADDR base_addr);
 318 void unloaded_dll (const char *name, CORE_ADDR base_addr);
 319
 320 /* Public variables in server.c */
 321
 322 extern ptid_t cont_thread;
 323 extern ptid_t general_thread;
 324 extern ptid_t step_thread;
 325
 326 extern int server_waiting;
 327 extern int debug_threads;
 328 extern int debug_hw_points;
 329 extern int pass_signals[];
 330
 331 extern jmp_buf toplevel;
 332
 333 extern int disable_packet_vCont;
 334 extern int disable_packet_Tthread;
 335 extern int disable_packet_qC;
 336 extern int disable_packet_qfThreadInfo;
 337
 338 extern int multi_process;
 339 extern int non_stop;
 340
 341 #if USE_WIN32API
 342 #include <winsock2.h>
 343 typedef SOCKET gdb_fildes_t;
 344 #else
 345 typedef int gdb_fildes_t;
 346 #endif
 347
 348 /* Functions from event-loop.c.  */
 349 typedef void *gdb_client_data;
 350 typedef int (handler_func) (int, gdb_client_data);
 351 typedef int (callback_handler_func) (gdb_client_data);
 352
 353 extern void delete_file_handler (gdb_fildes_t fd);
 354 extern void add_file_handler (gdb_fildes_t fd, handler_func *proc,
 355                               gdb_client_data client_data);
 356 extern int append_callback_event (callback_handler_func *proc,
 357                                    gdb_client_data client_data);
 358 extern void delete_callback_event (int id);
 359
 360 extern void start_event_loop (void);
 361
 362 /* Functions from server.c.  */
 363 extern int handle_serial_event (int err, gdb_client_data client_data);
 364 extern int handle_target_event (int err, gdb_client_data client_data);
 365
 366 extern void push_event (ptid_t ptid, struct target_waitstatus *status);
 367
 368 /* Functions from hostio.c.  */
 369 extern int handle_vFile (char *, int, int *);
 370
 371 /* Functions from hostio-errno.c.  */
 372 extern void hostio_last_error_from_errno (char *own_buf);
 373
 374 /* From remote-utils.c */
 375
 376 extern int remote_debug;
 377 extern int noack_mode;
 378 extern int transport_is_reliable;
 379
 380 int gdb_connected (void);
 381
 382 ptid_t read_ptid (char *buf, char **obuf);
 383 char *write_ptid (char *buf, ptid_t ptid);
 384
 385 int putpkt (char *buf);
 386 int putpkt_binary (char *buf, int len);
 387 int putpkt_notif (char *buf);
 388 int getpkt (char *buf);
 389 void remote_open (char *name);
 390 void remote_close (void);
 391 void write_ok (char *buf);
 392 void write_enn (char *buf);
 393 void initialize_async_io (void);
 394 void enable_async_io (void);
 395 void disable_async_io (void);
 396 void check_remote_input_interrupt_request (void);
 397 void convert_ascii_to_int (const char *from, unsigned char *to, int n);
 398 void convert_int_to_ascii (const unsigned char *from, char *to, int n);
 399 void new_thread_notify (int id);
 400 void dead_thread_notify (int id);
 401 void prepare_resume_reply (char *buf, ptid_t ptid,
 402                            struct target_waitstatus *status);
 403
 404 const char *decode_address_to_semicolon (CORE_ADDR *addrp, const char *start);
 405 void decode_address (CORE_ADDR *addrp, const char *start, int len);
 406 void decode_m_packet (char *from, CORE_ADDR * mem_addr_ptr,
 407                       unsigned int *len_ptr);
 408 void decode_M_packet (char *from, CORE_ADDR * mem_addr_ptr,
 409                       unsigned int *len_ptr, unsigned char **to_p);
 410 int decode_X_packet (char *from, int packet_len, CORE_ADDR * mem_addr_ptr,
 411                      unsigned int *len_ptr, unsigned char **to_p);
 412 int decode_xfer_write (char *buf, int packet_len, char **annex,
 413                        CORE_ADDR *offset, unsigned int *len,
 414                        unsigned char *data);
 415 int decode_search_memory_packet (const char *buf, int packet_len,
 416                                  CORE_ADDR *start_addrp,
 417                                  CORE_ADDR *search_space_lenp,
 418                                  gdb_byte *pattern, unsigned int *pattern_lenp);
 419
 420 int unhexify (char *bin, const char *hex, int count);
 421 int hexify (char *hex, const char *bin, int count);
 422 int remote_escape_output (const gdb_byte *buffer, int len,
 423                           gdb_byte *out_buf, int *out_len,
 424                           int out_maxlen);
 425 char *unpack_varlen_hex (char *buff,  ULONGEST *result);
 426
 427 void clear_symbol_cache (struct sym_cache **symcache_p);
 428 int look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb);
 429
 430 int relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc);
 431
 432 void monitor_output (const char *msg);
 433
 434 char *xml_escape_text (const char *text);
 435
 436 /* Simple growing buffer.  */
 437
 438 struct buffer
 439 {
 440   char *buffer;
 441   size_t buffer_size; /* allocated size */
 442   size_t used_size; /* actually used size */
 443 };
 444
 445 /* Append DATA of size SIZE to the end of BUFFER.  Grows the buffer to
 446    accommodate the new data.  */
 447 void buffer_grow (struct buffer *buffer, const char *data, size_t size);
 448
 449 /* Release any memory held by BUFFER.  */
 450 void buffer_free (struct buffer *buffer);
 451
 452 /* Initialize BUFFER.  BUFFER holds no memory afterwards.  */
 453 void buffer_init (struct buffer *buffer);
 454
 455 /* Return a pointer into BUFFER data, effectivelly transfering
 456    ownership of the buffer memory to the caller.  Calling buffer_free
 457    afterwards has no effect on the returned data.  */
 458 char* buffer_finish (struct buffer *buffer);
 459
 460 /* Simple printf to BUFFER function.  Current implemented formatters:
 461    %s - grow an xml escaped text in OBSTACK.  */
 462 void buffer_xml_printf (struct buffer *buffer, const char *format, ...)
 463   ATTR_FORMAT (printf, 2, 3);
 464
 465 #define buffer_grow_str(BUFFER,STRING)         \
 466   buffer_grow (BUFFER, STRING, strlen (STRING))
 467 #define buffer_grow_str0(BUFFER,STRING)                        \
 468   buffer_grow (BUFFER, STRING, strlen (STRING) + 1)
 469
 470 /* Functions from utils.c */
 471
 472 void *xmalloc (size_t) ATTR_MALLOC;
 473 void *xrealloc (void *, size_t);
 474 void *xcalloc (size_t, size_t) ATTR_MALLOC;
 475 char *xstrdup (const char *) ATTR_MALLOC;
 476 int xsnprintf (char *str, size_t size, const char *format, ...)
 477   ATTR_FORMAT (printf, 3, 4);;
 478 void freeargv (char **argv);
 479 void perror_with_name (const char *string);
 480 void error (const char *string,...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2);
 481 void fatal (const char *string,...) ATTR_NORETURN ATTR_FORMAT (printf, 1, 2);
 482 void internal_error (const char *file, int line, const char *, ...)
 483      ATTR_NORETURN ATTR_FORMAT (printf, 3, 4);
 484 void warning (const char *string,...) ATTR_FORMAT (printf, 1, 2);
 485 char *paddress (CORE_ADDR addr);
 486 char *pulongest (ULONGEST u);
 487 char *plongest (LONGEST l);
 488 char *phex_nz (ULONGEST l, int sizeof_l);
 489 char *pfildes (gdb_fildes_t fd);
 490
 491 #define gdb_assert(expr)                                                      \
 492   ((void) ((expr) ? 0 :                                                       \
 493            (gdb_assert_fail (#expr, __FILE__, __LINE__, ASSERT_FUNCTION), 0)))
 494
 495 /* Version 2.4 and later of GCC define a magical variable `__PRETTY_FUNCTION__'
 496    which contains the name of the function currently being defined.
 497    This is broken in G++ before version 2.6.
 498    C9x has a similar variable called __func__, but prefer the GCC one since
 499    it demangles C++ function names.  */
 500 #if (GCC_VERSION >= 2004)
 501 #define ASSERT_FUNCTION         __PRETTY_FUNCTION__
 502 #else
 503 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
 504 #define ASSERT_FUNCTION         __func__
 505 #endif
 506 #endif
 507
 508 /* This prints an "Assertion failed" message, and exits.  */
 509 #if defined (ASSERT_FUNCTION)
 510 #define gdb_assert_fail(assertion, file, line, function)                \
 511   internal_error (file, line, "%s: Assertion `%s' failed.",             \
 512                   function, assertion)
 513 #else
 514 #define gdb_assert_fail(assertion, file, line, function)                \
 515   internal_error (file, line, "Assertion `%s' failed.",                 \
 516                   assertion)
 517 #endif
 518
 519 /* Maximum number of bytes to read/write at once.  The value here
 520    is chosen to fill up a packet (the headers account for the 32).  */
 521 #define MAXBUFBYTES(N) (((N)-32)/2)
 522
 523 /* Buffer sizes for transferring memory, registers, etc.   Set to a constant
 524    value to accomodate multiple register formats.  This value must be at least
 525    as large as the largest register set supported by gdbserver.  */
 526 #define PBUFSIZ 16384
 527
 528 /* Functions from tracepoint.c */
 529
 530 int in_process_agent_loaded (void);
 531
 532 void initialize_tracepoint (void);
 533
 534 extern int tracing;
 535 extern int disconnected_tracing;
 536
 537 void tracepoint_look_up_symbols (void);
 538
 539 void stop_tracing (void);
 540
 541 int handle_tracepoint_general_set (char *own_buf);
 542 int handle_tracepoint_query (char *own_buf);
 543
 544 int tracepoint_finished_step (struct thread_info *tinfo, CORE_ADDR stop_pc);
 545 int tracepoint_was_hit (struct thread_info *tinfo, CORE_ADDR stop_pc);
 546
 547 void release_while_stepping_state_list (struct thread_info *tinfo);
 548
 549 extern int current_traceframe;
 550
 551 int in_readonly_region (CORE_ADDR addr, ULONGEST length);
 552 int traceframe_read_mem (int tfnum, CORE_ADDR addr,
 553                          unsigned char *buf, ULONGEST length,
 554                          ULONGEST *nbytes);
 555 int fetch_traceframe_registers (int tfnum,
 556                                 struct regcache *regcache,
 557                                 int regnum);
 558
 559 int traceframe_read_sdata (int tfnum, ULONGEST offset,
 560                            unsigned char *buf, ULONGEST length,
 561                            ULONGEST *nbytes);
 562
 563 /* If a thread is determined to be collecting a fast tracepoint, this
 564    structure holds the collect status.  */
 565
 566 struct fast_tpoint_collect_status
 567 {
 568   /* The tracepoint that is presently being collected.  */
 569   int tpoint_num;
 570   CORE_ADDR tpoint_addr;
 571
 572   /* The address range in the jump pad of where the original
 573      instruction the tracepoint jump was inserted was relocated
 574      to.  */
 575   CORE_ADDR adjusted_insn_addr;
 576   CORE_ADDR adjusted_insn_addr_end;
 577 };
 578
 579 int fast_tracepoint_collecting (CORE_ADDR thread_area,
 580                                 CORE_ADDR stop_pc,
 581                                 struct fast_tpoint_collect_status *status);
 582 void force_unlock_trace_buffer (void);
 583
 584 int handle_tracepoint_bkpts (struct thread_info *tinfo, CORE_ADDR stop_pc);
 585
 586 #ifdef IN_PROCESS_AGENT
 587 void initialize_low_tracepoint (void);
 588 void supply_fast_tracepoint_registers (struct regcache *regcache,
 589                                        const unsigned char *regs);
 590 void supply_static_tracepoint_registers (struct regcache *regcache,
 591                                          const unsigned char *regs,
 592                                          CORE_ADDR pc);
 593 #else
 594 void stop_tracing (void);
 595 #endif
 596
 597 /* Bytecode compilation function vector.  */
 598
 599 struct emit_ops
 600 {
 601   void (*emit_prologue) (void);
 602   void (*emit_epilogue) (void);
 603   void (*emit_add) (void);
 604   void (*emit_sub) (void);
 605   void (*emit_mul) (void);
 606   void (*emit_lsh) (void);
 607   void (*emit_rsh_signed) (void);
 608   void (*emit_rsh_unsigned) (void);
 609   void (*emit_ext) (int arg);
 610   void (*emit_log_not) (void);
 611   void (*emit_bit_and) (void);
 612   void (*emit_bit_or) (void);
 613   void (*emit_bit_xor) (void);
 614   void (*emit_bit_not) (void);
 615   void (*emit_equal) (void);
 616   void (*emit_less_signed) (void);
 617   void (*emit_less_unsigned) (void);
 618   void (*emit_ref) (int size);
 619   void (*emit_if_goto) (int *offset_p, int *size_p);
 620   void (*emit_goto) (int *offset_p, int *size_p);
 621   void (*write_goto_address) (CORE_ADDR from, CORE_ADDR to, int size);
 622   void (*emit_const) (LONGEST num);
 623   void (*emit_call) (CORE_ADDR fn);
 624   void (*emit_reg) (int reg);
 625   void (*emit_pop) (void);
 626   void (*emit_stack_flush) (void);
 627   void (*emit_zero_ext) (int arg);
 628   void (*emit_swap) (void);
 629   void (*emit_stack_adjust) (int n);
 630
 631   /* Emit code for a generic function that takes one fixed integer
 632      argument and returns a 64-bit int (for instance, tsv getter).  */
 633   void (*emit_int_call_1) (CORE_ADDR fn, int arg1);
 634
 635   /* Emit code for a generic function that takes one fixed integer
 636      argument and a 64-bit int from the top of the stack, and returns
 637      nothing (for instance, tsv setter).  */
 638   void (*emit_void_call_2) (CORE_ADDR fn, int arg1);
 639 };
 640
 641 /* Returns the address of the get_raw_reg function in the IPA.  */
 642 CORE_ADDR get_raw_reg_func_addr (void);
 643
 644 CORE_ADDR current_insn_ptr;
 645 int emit_error;
 646
 647 /* Version information, from version.c.  */
 648 extern const char version[];
 649 extern const char host_name[];
 650
 651 #endif /* SERVER_H */