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