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