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