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